java8-3 多態的好處和弊端以及多態的理解

多態的好處：
A:提高了代碼的維護性(繼承保證)
B:提高了代碼的擴展性(由多態保證)

貓狗案例代碼

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

class Dog extends Animal {
    public void eat(){
        System.out.println("狗吃肉");
    }
    
    public void sleep(){
        System.out.println("狗站着睡覺");
    }
}

class Cat extends Animal {
    public void eat() {
        System.out.println("貓吃魚");
    }
    
    public void sleep() {
        System.out.println("貓趴着睡覺");
    }
}

class Pig extends Animal {
    public void eat() {
        System.out.println("豬吃白菜");
    }
    
    public void sleep() {
        System.out.println("豬側着睡");
    }
}

//針對動物操作的工具類
class AnimalTool {
    private AnimalTool(){}

    /*
    //調用貓的功能
    public static void useCat(Cat c) {
        c.eat();
        c.sleep();
    }
    
    //調用狗的功能
    public static void useDog(Dog d) {
        d.eat();
        d.sleep();
    }
    
    //調用豬的功能
    public static void usePig(Pig p) {
        p.eat();
        p.sleep();
    }
    */
    public static void useAnimal(Animal a) {
        a.eat();
        a.sleep();
    }
    //把所有的可能都歸為動物類
}

class DuoTaiDemo2 {
    public static void main(String[] args) {
        //我喜歡貓，就養了一只
        Cat c = new Cat();
        c.eat();
        c.sleep();
        
        //我很喜歡貓，所以，又養了一只
        Cat c2 = new Cat();
        c2.eat();
        c2.sleep();
        
        //我特別喜歡貓，又養了一只
        Cat c3 = new Cat();
        c3.eat();
        c3.sleep();
        //...
        System.out.println("--------------");
        //問題來了,我養了很多只貓，每次創建對象是可以接受的
        //但是呢?調用方法，你不覺得很相似嗎?僅僅是對象名不一樣。
        //我們准備用方法改進
        //調用方式改進版本
        //useCat(c);
        //useCat(c2);
        //useCat(c3);
        
        //AnimalTool.useCat(c);
        //AnimalTool.useCat(c2);
        //AnimalTool.useCat(c3);
        
        AnimalTool.useAnimal(c);
        AnimalTool.useAnimal(c2);
        AnimalTool.useAnimal(c3);
        System.out.println("--------------");
        
        //我喜歡狗
        Dog d = new Dog();
        Dog d2 = new Dog();
        Dog d3 = new Dog();
        //AnimalTool.useDog(d);
        //AnimalTool.useDog(d2);
        //AnimalTool.useDog(d3);
        AnimalTool.useAnimal(d);
        AnimalTool.useAnimal(d2);
        AnimalTool.useAnimal(d3);
        System.out.println("--------------");
        
        //我喜歡寵物豬
        //定義一個豬類，它要繼承自動物，提供兩個方法，並且還得在工具類中添加該類方法調用
        Pig p = new Pig();
        Pig p2 = new Pig();
        Pig p3 = new Pig();
        //AnimalTool.usePig(p);
        //AnimalTool.usePig(p2);
        //AnimalTool.usePig(p3);
        AnimalTool.useAnimal(p);
        AnimalTool.useAnimal(p2);
        AnimalTool.useAnimal(p3);
        System.out.println("--------------");
        
        //我喜歡寵物狼，老虎，豹子...
        //定義對應的類，繼承自動物，提供對應的方法重寫，並在工具類添加方法調用
        //前面幾個必須寫，我是沒有意見的
        //但是，工具類每次都改，麻煩不
        //我就想，你能不能不改了
        //太簡單：把所有的動物都寫上。問題是名字是什么呢?到底哪些需要被加入呢?
        //改用另一種解決方案。
        
    }
    
    /*
    //調用貓的功能
    public static void useCat(Cat c) {
        c.eat();
        c.sleep();
    }
    
    //調用狗的功能
    public static void useDog(Dog d) {
        d.eat();
        d.sleep();
    }
    */
}

2、

多態的弊端：
不能使用子類的特有功能。

我就想使用子類的特有功能?行不行?
行。

怎么用呢?
A:創建子類對象調用方法即可。(可以，但是很多時候不合理。而且，太占內存了)
B:把父類的引用強制轉換為子類的引用。(向下轉型)

對象間的轉型問題：
向上轉型：
Fu f = new Zi();
向下轉型：
Zi z = (Zi)f; //要求該f必須是能夠轉換為Zi的.(所屬關系)

多態的問題理解：
class 孔子爹 {
public int age = 40;

public void teach() {
System.out.println("講解JavaSE");
}
}

class 孔子 extends 孔子爹 {
public int age = 20;

public void teach() {
System.out.println("講解論語");
}

public void playGame() {
System.out.println("英雄聯盟");
}
}

//Java培訓特別火,很多人來請孔子爹去講課，這一天孔子爹被請走了
//但是還有人來請，就剩孔子在家，價格還挺高。孔子一想，我是不是可以考慮去呢?
//然后就穿上爹的衣服，帶上爹的眼睛，粘上爹的胡子。就開始裝爹
//向上轉型
孔子爹 k爹 = new 孔子();
//到人家那里去了
System.out.println(k爹.age); //40
k爹.teach(); //講解論語
//k爹.playGame(); //這是兒子才能做的


//講完了，下班回家了
//脫下爹的裝備，換上自己的裝備
//向下轉型
孔子 k = (孔子) k爹;
System.out.println(k.age); //20
k.teach(); //講解論語
k.playGame(); //英雄聯盟

2、向下轉型中有可能的異常：
ClassCastException:類型轉換異常
一般在多態的向下轉型中容易出現