我無法調用子類中定義的方法

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();
    }
}