一、多型

1、多型概述：

某一個事物，在不同時刻表現出來的不同狀態。
    舉例：
        動物（狗，貓，雞...）
        水（氣態，液態，固態）
class Animal{
}
​
class Dog extends Animal{
    String name;
    String type;
}

2、多型的前提：（同時滿足）

1）、要有繼承關係
2）、要有方法重寫
    你可以不去重寫，但是呢，如果不重寫，從常理來說，就無法體現子類的特性
3）、要有父類引用指向子類物件
     父 f = new 子();
     動物 d = new 狗(); //讀法：從右往左去讀  狗是動物
     水 s = new 冰(); //讀法：從右往左去讀  冰是是水
 

3、多型訪問成員的特點：

1、成員變數
   編譯看左邊，執行也看左邊。
   編譯看左邊，指的是看父類中有沒有該成員變數，如果有說明編譯不報錯，可以進行訪問
   執行看左邊，指的是編譯不報錯的前提下，去訪問父類中變數值。
2、構造方法
   建立子類物件的時候，先初始化子類（先呼叫子類的構造方法），
   再初始化父類（子類中的構造方法第一句預設有一個super()）
3、成員方法
   編譯看左邊，執行看右邊
4、靜態方法
   編譯看左邊，執行也看左邊
   算不上重寫了，訪問的是類本身的東西

4、用程式碼體現多型

class Animal{
    String name;
    String type;
    int a = 10;
    Animal(){
        System.out.println("Animal中的無參構造方法");
    }
    public void eat(){
        System.out.println("吃飯");
    }
    public static void sleep(){
        System.out.println("睡覺");
    }
}
​
class Dog extends Animal{
    int a = 20;
    Dog(){
        System.out.println("Dog中的無參構造方法");
    }
    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }
    public static void sleep(){
        System.out.println("側著睡");
    }
}
​
public class PolymorphicDemo1 {
    public static void main(String[] args) {
        //多型類建立物件
        Animal animal = new Dog();
        animal.eat();
        animal.sleep();
    }
}
 

5、多型有什麼好處

1）、程式碼擴充套件性很好（由繼承所帶來的好處）
2）、程式碼的維護性很好（由多型所帶來的好處）

class Animal2{
    String name;
    int age;
    Animal2(){
        
    }
​
    Animal2(String name,int age){
        this.name = name;
        this.age = age;
    }
​
    public void eat(){
        System.out.println("吃飯");
    }
​
    public void sleep(){
        System.out.println("睡覺");
    }
}
​
class Dog2 extends Animal2{
    Dog2(String name,int age){
        this.name = name;
        this.age = age;
    }
​
    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }
​
    @Override
    public void sleep() {
        System.out.println("狗側著睡");
    }
}
​
class Alpaca extends Animal2{
    Alpaca(String name,int age){
        this.name = name;
        this.age = age;
    }
​
    @Override
    public void eat() {
        System.out.println("羊駝吃草");
    }
​
    @Override
    public void sleep() {
        System.out.println("羊駝臥著睡");
    }
}
​
class Panda extends Animal2{
    Panda(String name,int age){
        this.name = name;
        this.age = age;
    }
​
    @Override
    public void eat() {
        System.out.println("熊貓吃竹子");
    }
​
    @Override
    public void sleep() {
        System.out.println("熊貓隨便睡");
    }
}
​
​
class AnimalTool{
    private AnimalTool(){
    }
//訪問狗的方法
//    public static void useDog(Dog2 dog2){
//        dog2.eat();
//        dog2.sleep();
//    }
//
//    //訪問羊駝的方法
//    public static void useAlpaca(Alpaca alpaca){
//        alpaca.eat();
//        alpaca.sleep();
//    }
​
//訪問熊貓的方法
​
//訪問老虎的方法
//...
​
public static void useAnimal(Animal2 animal){  // Animal2 animal2 = new         Panda("團團", 2);
    animal.eat();
    animal.sleep();
    }
}
​
public class CatDogDemo {
    public static void main(String[] args) {
        //現在我想養一隻狗
        Dog2 d1 = new Dog2("小花", 3);
//        d1.eat();
//        d1.sleep();
//        useDog(d1);
//        AnimalTool.useDog(d1);
        AnimalTool.useAnimal(d1);
​
•    //我想再養一條狗
•    Dog2 d2 = new Dog2("奶糖", 4);
​
//        d2.eat();
//        d2.sleep();
//        useDog(d2);
//        AnimalTool.useDog(d2);
        AnimalTool.useAnimal(d2);
​
•    //我還想養一條狗
•    Dog2 d3 = new Dog2("旺財", 2);
​
//        d3.eat();
//        d3.sleep();
//        useDog(d3);
//        AnimalTool.useDog(d3);
        AnimalTool.useAnimal(d3);
​
•    //你不覺得每次呼叫方法都需要寫一遍eat()和sleep
•    //使用方法改進
​
•    //我想養只羊駝
•    Alpaca a1 = new Alpaca("小白", 2);
​
//        a1.eat();
//        a1.sleep();
//        useAlpaca(a1);
//        AnimalTool.useAlpaca(a1);
        AnimalTool.useAnimal(a1);
​
•    //再養只羊駝
•    Alpaca a2 = new Alpaca("小黃", 3);
​
//        a2.eat();
//        a2.sleep();
//        useAlpaca(a2);
//        AnimalTool.useAlpaca(a2);
        AnimalTool.useAnimal(a2);
​
•    Alpaca a3 = new Alpaca("小黑", 3);
​
//        a3.eat();
//        a3.sleep();
//        useAlpaca(a3);
//        AnimalTool.useAlpaca(a3);
        AnimalTool.useAnimal(a3);
​
•    //如果我現在不想養羊駝了，想養熊貓
•    //是不是養n只熊貓，要new出n次
•    //每個熊貓也有吃和睡的方法
•    //按照上面的寫程式碼的習慣，再額外新增一個熊貓的方法
•    //但是，將來我還有可能養老虎，獅子，豹子等等。。。
•    //這些動物按照上面的寫程式碼的習慣,是不是應該都需要寫一個方法，最後會發現這個程式非常臃腫雜亂
•    //回想一下，我們之前將多個方法操作同一型別的時候，我們用工具類進行改進的
•    //用工具類改進之後，將來再想養新的動物，只要在工具類中新增一個新的動物方法就可以
​
•    //但是呢，工具理論上不允許修改的
•    //所以我們需要再次改進
•    //怎麼改進呢？使用多型改進
•    Panda p1 = new Panda("團團", 2);
•    AnimalTool.useAnimal(p1);
•    Panda p2 = new Panda("圓圓", 3);
•    AnimalTool.useAnimal(p2);
•    Panda p3 = new Panda("平平", 4);
•    AnimalTool.useAnimal(p3);
​
}
​
//    //訪問狗的方法
//    public static void useDog(Dog2 dog2){
//        dog2.eat();
//        dog2.sleep();
//    }
//
//    //訪問羊駝的方法
//    public static void useAlpaca(Alpaca alpaca){
//        alpaca.eat();
//        alpaca.sleep();
//    }
//
//    //訪問熊貓的方法
//
//    //訪問老虎的方法
//    //...
}