java面向物件的三大特性：繼承，封裝，多型

繼承和封裝也為多型做了鋪墊。

多型的概念，這裡我說的我的理解。概念我理解，但我自問自己能不能時刻記住多型的概念。我投降

多型其實就是一個引用指向多個物件。

打個比方：

班主任找班裡的重要人員去101開個會，如果說學習委員，衛生委員，班長，副班長，體育委員，文藝委員，宣傳委員等等。

你感覺老師會這麼蠢嗎？一般來說，班主任會直接說：班級幹部來101開一下會。

所以雖說只引用班級幹部，但是卻指向了很多物件。

程式碼體現：

父類 引用變數=new 子類物件();//是兩個型別

例子：

class Animal{
    String name;
}

class Cat extends Animal{
}

class Dog extends Animal{
    
}

class Demo{
    public static void main(String[] args){
        Animal a=new Dog();
        Animal a2=new Cat();
    }
}
 

【多型的優點（以例子說話）】

1.擴充套件性：

就算派生了其他的子類，也不會影響已存在的子類。

2.靈活性，複用性：

你敢信可以用父類引用呼叫子類的屬性和行為？

class Person{
    public void drinkWater(Cup c){
        System.out.println("use "+Cup.getName()+" drink water")
    }
}

class Cup{
    private String name;

    public void setName(String name){
        this.name=name;
    }

    public String getName(){
        return this.name;
    }
    public Cup(String name){
        this.name=name;
    }
}
@override
class Mug extends Cup{
    public Cup(String name){
        super(name);
    }
}

class Demo{
    public static void main(String[] args){
        Cup c=new Mug("馬克杯");
        Person p=new Person();
        p.drinkWater(c);
    }
}
 

 【多型的弊端】

通過父類引用操控子類物件，只能操作父類和子類共有的方法，而子類自己衍生的方法或是屬性是無法操控的。

換句話來說，爸爸教了兒子打籃球之後。爸爸和兒子都可以呼叫打籃球。兒子自己學會踢足球。爸爸會嗎？爸爸不會怎麼呼叫踢足球這個方法。

class Fu{
    String name;
    public void show(){
        System.out.println("Fu");
    }
}

class Zi extends Fu{
    public void show(){
        super.show();
    }
    
    public void show2(){
        System.out.println("Zi");
    }
}

class Demo{
    public static void main(String[] args){
        Fu f=new Zi();
        f.show();//編譯通過
        f.show2();//報錯
    }
}
 

【多型的前提】

1.必須由關係：繼承或者介面都行。

2.通常子類繼承父類後通常要重寫父類的方法。 

3.父類的引用指向子類物件。

那如果子類的物件，父類該如何呼叫呢？

通過instance關鍵字向下轉型

class Fu{
    public void work(){
        System.out.println("工作");
    }
}

class Zi extends Fu{
    public void work(){
        super.work();
    }

    public void practice(){
        System.out.prinln("引體向上50個，再加200個俯臥撐，300個仰臥起坐，加5*500米快速跑");
    }
}

class Nv extends Fu{
}

class Demo{
    public static void main(String[] args){
        Fu f=new Zi();
        Fu f2=new Nv():
        f.work();
        if(f instanceof Zi){
            Zi zf=(Zi)f;
            zf.practice();
        }else{
            new ClassCastExcetion("快停下朋友，你是瘋了嗎？我以後只能託夢見你了？")
        }
    }
}

向上轉型：就是我們所說的多型。

向下轉型：可以理解為基本資料型別中的強制型別轉換。

那麼為什麼要用instanceof呢？

因為如果女兒也繼承父類，然後也向下轉型了。然後如果成功了，呼叫了兒子的鍛鍊。

結果只有2個：1.恭喜你，第二天就可以全家燒香了。2.恭喜你，你女兒這麼身材那麼的彪悍都能結婚。

【例項】：例項其實很多，網上可以找到很多，本人就舉一個例子了

【筆記本和USB的故事】

interface USB{ 
    public void setName(String name);
    public String setName();
}

class Mouse implements USB{
    public Mouse(String name){
        this.name=name;
}
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }
}

class KeyBoard implements USB{
    public KeyBoard(String name){
        this.name=name;
    }    
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }
}

class abstract Computer{
    private String name;
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
}
    public void open(){
        System.out.println("開啟電腦");
    }
    public void close(){
        System.out.println("關閉電腦");
    }
    publc void useUSB(Computer c,USB u);
}

class NoteBook extends Computer{
    public void open(){
        super.open();
    }
    public void close(){
        super.close();
    }
    public void useUSB(Computer c,USB u){
        super.useUSB(c,u);
    }
    publc void useUSB(Computer c,USB u){
        System.out.println(c.getName()+" use "+u.getName());
    }
}

class Demo{
    public static void main(String[] args){
        Computer c=new NookBook("筆記本");
        c.open();
        c.close();
        c.useUSB(c,new Mouse("滑鼠"));
    }
}