Java 繼承與多型超詳細梳理

public class Base {
    int a;
    int b;
    int c;
} 
public class Derived extends Base{
    int a; // 與父類別中成員a同名，且型別相同
    char b; // 與父類別中成員b同名，但型別不同
    public void method(){
        a = 100; // 存取父類別繼承的a，還是子類自己新增的a？
        b = 101; // 存取父類別繼承的b，還是子類自己新增的b?
        c = 102; // 子類沒有c，存取的肯定是從父類別繼承下來的c
    }
}

public class Base {
    int a;
    int b;
    public void methodA(){
        System.out.println("Base中的methodA()");
    }
    public void methodB(){
        System.out.println("Base中的methodB()");
}
public class Derived extends Base{
    int a; 
    char b; 
    // 與父類別中methodA()構成過載
    public void methodA(int a) {
        System.out.println("Derived中的method()方法");
    }
    // 與父類別中methodB()構成重寫
    public void methodB(){
        System.out.println("Derived中的methodB()方法");
    }
    public void methodC(){
        a = 100; // 等價於： this.a = 100;
        b = 101; // 等價於： this.b = 101;
        // 存取父類別的成員變數時，需要藉助super關鍵字
        // super是獲取到子類物件中從基礎類別繼承下來的部分
        super.a = 200;
        super.b = 201;
        methodA(); // 沒有傳參，存取父類別中的methodA()
        methodA(20); // 傳遞int引數，存取子類中的methodA(int)
        methodB(); // 直接存取，則永遠存取到的都是子類中的methodA()，基礎類別的無法存取到
        super.methodB(); // 存取基礎類別的methodB()
    }
}

public class Base {
    public Base(){
        System.out.println("Base()");
    }
}
public class Derived extends Base{
    public Derived(){
   // super(); // 注意子類構造方法中預設會呼叫基礎類別的無參構造方法：super(),
   // 使用者沒有寫時,編譯器會自動新增，而且super()必須是子類構造方法中第一條語句，
   // 並且只能出現一次
        System.out.println("Derived()");
    }
}

public class TestAnimal {
    // 2. 函數傳參：形參為父類別參照，可以接收任意子類的物件
    public static void eatFood(Animal a) {
        a.eat();
    }
 
    // 3. 作返回值：返回任意子類物件
    public static Animal buyAnimal(String var) {
        if ("狗" == var) {
            return new Dog("狗狗", 1);
        } else if ("貓" == var) {
            return new Cat("貓貓", 1);
        } else {
            return null;
        }
    }
 
    public static void main(String[] args) {
        Animal cat = new Cat("元寶", 2); // 1. 直接賦值：子類物件賦值給父類別物件
        Dog dog = new Dog("小七", 1);
    }
}

public class Animal(){
    String name;
    int age;
    public Animal(String name, int age){
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println(name + "吃飯");
        }
}
public class Cat extends Animal{
    public Cat(String name, int age){
        super(name, age);
    }
    @Override
    public void eat(){
        System.out.println(name+"吃魚~~~");
    }
}
public class Dog extends Animal {
    public Dog(String name, int age){
        super(name, age);
    }
    @Override
    public void eat(){
        System.out.println(name+"吃骨頭~~~");
    }
}
public class TestAnimal {
    // 編譯器在編譯程式碼時，並不知道要呼叫Dog 還是 Cat 中eat的方法
   // 等程式執行起來後，形參a參照的具體物件確定後，才知道呼叫那個方法
   // 注意：此處的形參型別必須時父類別型別才可以
    public static void eat(Animal a){
        a.eat();
    }
    public static void main(String[] args) {
        Animal animal1 = new Cat("元寶",2);
        Animal animal2 = new Dog("小七", 1);
        eat(animal1);
        eat(animal2);
    }
}