我无法调用子类中定义的方法

Question

我有 2 节课：

public class Animal {
    
    protected String name;
    int age;
    
    
    public Animal(String name, int age) {
        // TODO Auto-generated constructor stub
    
        this.name = name;
        this.age = age;
    }
    
    public static void eating() {
        System.out.println("eating");
    }
}

public class Human extends Animal{

    public Human(String name, int age) {
        // TODO Auto-generated constructor stub
        super(name, age);
    }
    
    
    public static void talking() {
        System.out.println("Talk");
    }
}

主程序：

public class program {
    
    public static void main (String [] args) {
    
        Animal hum = new Human("bob", 1);
        
        System.out.println(hum);
        //hum.talking();
        
    }

}

主程序的 output 是wk05.Human@7f690630 。 那么为什么我不能在主程序中做“hum.talking”呢？ 我对inheritance的理解是子类可以调用父类class中定义的方法以及子类中定义的方法。

Answer 1

在你的程序中Animal hum = new Human("bob", 1); 表示对Animal super class 的嗡嗡声引用，它没有talking()的定义，而 object 是Human 。

在编译时考虑参考而不是 object。 Object 在运行时使用。 因此，如果您想调用talking() ，您需要：

1) 创建对 Human class的引用这里的引用也是对Human class 的引用，因此它在编译时定义了talk talking()方法。

Human hum = new Human("bob", 1);
hum.talking();

2) 将 object 转换为 Human（仅用于理解类型转换）当我们转换 object 时，我们明确告诉编译器参考定义的 object。 所以可以参考。

Animal hum = new Human("bob", 1);
((Human) hum).talking();

背后的原因是，假设您还有一个 class SuperHuman ，它还扩展了Animal class 并且 class 没有会talking()方法，那么编译器将如何知道引用或Human hum会SuperHuman ？

假设在初始化期间，我们已经完成了Animal hum = new Human("bob", 1); 后来在代码中， hum被更新为hum = SuperHuman("sup", 10); . 这就是引用编译时引用并在运行时引用 Object 的原因。

Answer 2

该错误是编译错误； 编译器并不关心 object 类型实际上是（或可能是）什么，它只关心它声明的内容。

另外，我几乎可以肯定你的方法不应该是 static。

如果你要做一些你正在探索的事情，你必须抽象出方法，要么作为接口，要么作为抽象方法。 例如：

class abstract Animal {
    abstract void communicate();
}

class Dog extends Animal {
    void communicate() {
        System.out.println("bark");
    }
}

class Human extends Animal {
    void communicate() {
        System.out.println("talk");
    }
}

Answer 3

正如Gaurav所说，您必须创建对Human的引用或将Animal转换为Human 。 但是，如果 Animal 是接口或抽象 class （我不特别喜欢这样做）并公开了一个所有派生类都必须实现的方法，那么 inheritance 会更有意义。

public interface Animal {

    String getName();
    int getAge();
    void blab();
}

public class Human implements Animal {

    private String name;
    private int age;

    Human(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() { return name; }
    
    public int getAge() { return age; }

    public void blab() {
        System.out.println("Talk");
    }
}

而且主要

public class Program {

    public static void main(String[] args) {
        Animal animal = new Human("Bob", 1);
        animal.blab();
    }
}