How to call the overridden method of a superclass?

2019-07-28 16:50发布

站内文章 / 前端开发

77 0

聊天终结者

女 | 书童

私信

我怎样才能调用吃喝的方法， Animal类的myAnimal代码实例？

public class Animal {
    public void eat() {
        System.out.println("Animal Eats");
    }

    public void drink() {
        System.out.println("Animal Drinks");
    }
}

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("Cat Eats");
    }

    @Override
    public void drink() {
        System.out.println("Cat Drinks");
    }

    public static void main(String[] args) {
        Cat myCat = new Cat();
        myCat.eat();
        myCat.drink();

        Animal myAnimal = myCat;        
        myAnimal.eat();
        myAnimal.drink();
    }
}

输出我得到：

Cat Eats
Cat Drinks
Cat Eats
Cat Drinks

这是我期望的输出：

Cat Eats
Cat Drinks
Animal Eats
Animal Drinks

Answer 1:

你不能做你想做的。该方法多态性的作品是做你所看到的。

基本上，猫总是知道它是一只猫，将始终表现得像一只猫不管你把作为一只猫，猫，猫亚科，猫科动物，猫型亚目，食肉目，兽亚纲，哺乳纲，脊椎动物，脊索动物门，真后生动物，动物界，动物的，对象，或其他任何东西:-)

Answer 2:

在这里，你将有一个选项，选择你要调用的方法。

public class Cat extends Animal {

    public void superEat() {
        super.eat();
    }

    public void superDrink() {
        super.drink();
    }

    @Override
    public void eat() {
        System.out.println("Cat Eats");
    }

    @Override
    public void drink() {
        System.out.println("Cat Drinks");
    }
}

Answer 3:

这条线：

Animal myAnimal = myCat;

分配变量myAnimal对象myCat ，这你之前创建。所以，当你调用myAnimal.eat()后，你实际上是调用原来myCat对象，它输出的方法Cat Eats 。

如果你想输出Animal Eats ，你就必须到指定Animal实例变量。所以，如果你这样做，而不是：

Animal myAnimal = new Animal()

可变myAnimal将是一个实例Animal ，从而将覆盖先前分配给Cat 。

如果你调用myAnimal.eat()在此之后，你实际上调用eat()的方法Animal你已经创建的实例，将输出Animal Eats 。

结论：你的代码应为：

public class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("Cat Eats");
    }

    @Override
    public void drink() {
        System.out.println("Cat Drinks");
    }

    public static void main(String[] args) {
        Cat myCat = new Cat();
        myCat.eat();
        myCat.drink();

        Animal myAnimal = new Animal();        
        myAnimal.eat();
        myAnimal.drink();
    }
}

Answer 4:

访问静态字段，实例字段和静态方法依赖于类的引用变量，而不是实际的对象 ，该变量指向。
请记住，成员变量被屏蔽，无法覆盖。

这是在实例方法的情况下，会发生什么情况相反。
在实例方法的情况下的实际对象的类的方法被调用。

 class ABCD { int x = 10; static int y = 20; public String getName() { return "ABCD"; } } class MNOP extends ABCD { int x = 30; static int y = 40; public String getName() { return "MNOP"; } } public static void main(String[] args) { System.out.println(new MNOP().x + ", " + new MNOP().y); ABCD a = new MNOP(); System.out.println(ax); // 10 System.out.println(ay); // 20 System.out.println(a.getName()); // MNOP }

在这个例子中虽然对象myCat被分配给一个动物对象的引用，（ Animal myAnimal = myCat ）实际对象的类型是Cat和它的行为，因为它是猫。

希望这可以帮助。

Answer 5:

您可以创建类的动物，即另需马斯作为参数，并基于提供一个新的实例构造函数。

public class Animal {
    //some common animal's properties
    private int weight;
    private int age;

    public Animal() {
        // empty.
    }

    public Animal(final Animal otherAnimal) {
        this.weight = otherAnimal.getWeight();
        this.age = otherAnimal.getAge();
    }

    public void eat() {
        System.out.println("Animal Eats");
    }

    public void drink() {
        System.out.println("Animal Drinks");
    }

    // setters and getters.
}

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("Cat Eats");
    }

    @Override
    public void drink() {
        System.out.println("Cat Drinks");
    }

    public static void main(String[] args) {
        Cat myCat = new Cat();
        myCat.eat();
        myCat.drink();

        // note: myAnimal is not a Cat, it's just an Animal.
        Animal myAnimal = new Animal(myCat);         
        myAnimal.eat();
        myAnimal.drink();
    }
}

Answer 6:

如果您在每类中的方法静态的，它应该工作。

public class Animal {
    public static void eat() {
        System.out.println("Animal Eats");
    }

    public static void drink() {
        System.out.println("Animal Drinks");
    }
}


public class Cat extends Animal {
    @Override
    public static void eat() {
        System.out.println("Cat Eats");
    }

    @Override
    public static void drink() {
        System.out.println("Cat Drinks");
    }

    public static void main(String[] args) {
        Cat myCat = new Cat();
        myCat.eat();
        myCat.drink();

        Animal myAnimal = myCat;        
        myAnimal.eat();
        myAnimal.drink();
    }
}

上面的代码将给出以下输出

Cat Eats
Cat Drinks
Animal Eats
Animal Drinks

Answer 7:

几点建议：

不要子类引用传递给超类和除超类方法被调用的重写的方法。从调用父类的实例的超类方法。
```
 Animal myAnimal = new Animal(); myAnimal.eat(); 
```
如果你想从调用子类的超类的方法，显式调用父类方法的名称与super.methodName（）;
```
 public void eat() { super.eat(); System.out.println("Cat Eats"); } 
```
不要覆盖子类的超类的方法。始终父类方法被调用。

Answer 8:

public class Main {
    public static void main(String[] args) {
        Cat myCat = new Cat();
        myCat.eat();
        myCat.drink();

        Animal myAnimal = new Animal();
        myAnimal.eat();
        myAnimal.drink();
    }
}

public class Animal {
    public void eat(){
        System.out.println("Animal eat() called");
    }
    public void drink(){
        System.out.println("Animal drink() called");
    }
}

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("Cat eat() called");
    }

    @Override
    public void drink() {
        System.out.println("cat drink() called");
    }
}

OUTPUT：

猫吃（）称为
所谓的猫饮料（）
动物吃的（）称为
叫兽饮料（）

您需要创建超类的对象Animal或其他选项是使用关键字super在子类中的方法，例如， super.eat()或super.drink()

Answer 9:

猫不能不再是一只猫，即使它是一种动物。猫会吃和猫将猫的方式喝酒。这可能是类似于一种动物呢，这就是为什么它覆盖的方法。如果你想要它做的动物的默认操作是什么，不覆盖。你也许可以做一些奇怪的东西与反思并作出访问父方法，如不同的方法：

public void superDrink() {
   Animal.class.getMethod("drink").invoke();
}

但可能是矫枉过正你不觉得吗？

当然，这可能是行不通的，因为它不是静态的。

Answer 10:

请不要对这个答案投票......你可以在另外一个投票:-)这是一个不好回答，但显示你会怎么做你正在尝试做的......不好。

public class Main
{
    public static void main(final String[] argv) 
    {        
        Child  child;
        Parent parent;

        child  = new Child();
        parent = child;

        child.a();
        parent.a();
        child.otherA();
        parent.otherA();
    }
}

class Parent
{
    public void a()
    {
        System.out.println("Parent.a()");
    }

    public void otherA()
    {
        // doesn't matter what goes here... really should be abstract
    }
}

class Child
    extends Parent
{
    @Override
    public void a()
    {
        System.out.println("Child.a()");
    }

    @Override
    public void otherA()
    {
        super.a();
    }
}

文章来源: How to call the overridden method of a superclass?