Question

class GrandFather
{
    void display1()
    {
        System.out.println("I am grandfather");
    }
}

class Father extends GrandFather
{
    void display()
    {
        System.out.println("I am father");
    }
}

class Children extends Father
{
    void display()
    {
       System.out.println("I am Child");
    }

    public static void main(String []args)
    {
       Children obj = new Children();

       obj.display();
       obj.display();
       obj.display();
    }
}

当我编译这段代码时，它正在打印最后一个类的显示方法，所以告诉我如何将它转换为打印父类和其他类的显示

Answer 1

GrandFather obj = new GrandFather();

//打印祖父的显示方法。

obj = new Father();

//打印父亲的显示方法。

obj = new Children();

//打印Child的显示方法。如果你想要调用所有东西，可以在display（）方法中使用super。

Answer 2

如果您可以将父类中显示功能的名称更改为display2，则以下内容将起作用：

class GrandFather {
    void display1() {
        System.out.println("I am grandfather");
    }
}

class Father extends GrandFather {
    void display2() {
        System.out.println("I am father");
    }
}

class Children extends Father {
    void display() {
        System.out.println("I am Child");
    }

    public static void main(String[] args) {
        Children obj = new Children();

        obj.display1();
        obj.display2();
        obj.display();
    }
}

你想要实现的目标违反了OOPS概念的精神。

Answer 3

如果要在每个子对象上应用父对象行为，可以这样做：

class GrandFather {
    void display() {
        System.out.println("I am grandfather");
    }
}

class Father extends GrandFather {
    void display() {
        super.display();
        System.out.println("I am father");
    }
}

class Children extends Father {
    void display() {
        super.display();
        System.out.println("I am Child");
    }

    public static void main(String[] args) {
        Children obj = new Children();

        obj.display();
    }
}

Answer 4

除了GrandFather类之外，您可以在每个显示方法中调用super.display（），这将打印所有值。即祖父 - ＆gt;父亲 - ＆gt;子。

Answer 5

OOP概念（polymorphisme）。要使用父方法实现，您可以使用超类实例作为子引用。例如：

显示＆＃34;我是孩子＆＃34; ：

Children children = new Children ();
children.display();

显示＆＃34;我父亲＆＃34; ：

Children children = new Father ();
children.display();

显示＆＃34;我是大父亲＆＃34; ：

Children children = new GrandFather ();
children.display();

或者您可以在方法中使用super关键字：

class Children extends Father {
  public void display () {
     super.display();
  }
}

Children children = new Children ();
//Display "I'm a father"
children.display();

Answer 6

您需要学习的第一件事是正确缩进代码。你原来的代码太乱了，无法阅读。

其次，我们提出您要问的问题：您要求的是反对多态的原则（至少在Java中）。

如果您有Children个对象实例，虽然它可以被视为Father或GrandFather，但实际上它仍然是Children并且它充当Children即使您将其视为Father。它是OOP中最重要和最核心的原则之一。

因此，您无法使用Children个实例并将其设为Father（即在调用display()时，显示father而不是children）。

有一些方法可以解决它，一种方法是，正如其他答案已经提到的那样，不要覆盖要调用的方法。将它们分成单独的方法，例如

// in pseudo code
class GrandFather {
    public void displayAsGrandFather() { 
        print("I am grandfather"); 
    }
    public void display() { 
        displayAsGrandFather(); 
    }
}

class Father {
    public void displayAsFather() { 
        print("I am father"); 
    }
    public void display() { 
        displayAsFather(); 
    }
}
class Child {
    public void displayAsChild(){ 
        print("I am child"); 
    }
    public void display() { 
        displayAsChild();
    }
}

然后你可以做类似的事情：

Child child = new Child();
child.displayAsGrandFather();
child.displayAsFather();
child.displayAsChild();

或实际上在不同类型的对象实例上调用display()：

new Child().display();
new Father().display();
new GrandFather().display();

另一种不太明显的避免覆盖的方法是使display()成为静态方法，假设您没有使用任何实例成员。静态方法解析在编译时执行，而不是在运行时执行（如在正常的重写实例方法中）。

例如：

// in pseudo code
class GrandFather {
    public static void display() { 
        print("I am grandfather"); 
    }
}

class Father {
    public static void display() { 
        print("I am father"); 
    }
}
class Child {
    public static void display() { 
        print("I am child"); 
    }
}

因此，你可以做到

Child child = new Child();
child.display();    // will be translated to Child.display() by compiler
((Father)child).display();  // will be translated to Father.display() by compiler
((GrandFather)child).display();  // will be translated to GrandFather.display() by compiler

恕我直言，虽然这个问题不是无法解决的，但实际上对它进行讨论实际上毫无意义，因为它违背了OOP的原则，并且没有有意义的真实场景。

在继承的情况下，具有相同方法名称的不同类的Java程序

6 个答案: