摘要：同時繼承允許將對象視為它本身的類型或者它的父類型進行處理，這是使用繼承設計多態的基礎。水果青蘋果設置名字為設置名字為香蕉橙子那么就是的多態表現。

面向對象編程有三大特性：封裝、繼承、多態。
封裝：將事物特征和行為抽象出來，并隱藏內部具體的實現機制。隱藏即可以保護數據安全，也可以在不影響類的使用情況下對類進行修改。對外界而言，暴露的僅僅是一個方法。
繼承：若兩個類之間是is-a的關系，就可以使用extends關鍵字對父類的代碼進行復用。同時繼承允許將對象視為它本身的類型或者它的父類型進行處理，這是使用繼承設計多態的基礎。
多態：程序中定義的引用變量，它指向的具體類型和它的調用方法在編譯中并不確定，只有在程序運行時才確定。這樣，不用修改程序代碼，就可以讓引用變量綁定不同的具體類型，使得調用的方法也隨之改變。

多態分成編譯時多態和運行時多態。編譯時多態指的是方法的重載，屬于靜態多態，當編譯時，會根據參數列表來區分不同的方法，編譯完成后，會生成不同的方法。而運行時多態則為運行時動態綁定方法來實現，指的就是多態性。

多態性

前置概念：

方法綁定：將一個方法的調用和方法主體關聯起來就叫做方法綁定。
從多態的概念上可以看出，在程序中，方法綁定并不一定發生在程序運行期間，還有在程序運行前就綁定的情況。在程序運行前就綁定的稱作前期綁定，而在運行時根據對象具體類型進行綁定的稱作后期綁定或動態綁定。實現后期綁定必須有某種機制以便在運行時判斷對象的類型。

向上轉型：把一個對象的引用視為對它父類型的引用稱作向上轉型。缺陷：在使用過程中，只能以父類為基準，使用也只能使用父類中的屬性方法，導致丟失子類的一部分屬性和方法。
例如：蘋果，香蕉，橙子都是水果，實體類Apple,Banana,Orange全都繼承Fruit類。

public class Fruit {
    public void name(){
        System.out.println("水果");
    }
    public static void main(String[] arg0){
        Fruit apple = new Apple();
        apple.name();
    } 
}
class Apple extends Fruit{
    public void name(){
        System.out.println("青蘋果");
    }
    public void name(String name){
        System.out.println("設置名字為"+name);
    }
    public void setName(String color){
        System.out.println("設置名字為"+name);
    }
}
class Banana extends Fruit{
    public void name(){
        System.out.println("香蕉");
    }
}
class Orange extends Fruit{
    public void name(){
        System.out.println("橙子");
    }
}

那么

Fruit apple = new Apple();
Fruit banana = new Banana();
Fruit orange = new Orange();

就是Fruit的多態表現。可以理解成引用變量apple類型為Fruit，具體指向的則是Apple對象的實例，具體理解為：Apple對象繼承Fruit，所以Apple會自動的向上轉型為Fruit對象，所以apple可以指向Apple。但是由于使用了向上轉型，那么也會存在向上轉型的缺陷。例如：apple是不能使用name(String color)和setName(String name)方法的，不管是子類的屬性還是子類特有的方法，包括子類重載的方法。例如apple.name();可以得到值：青蘋果。但是，編寫apple.name("紅蘋果")或者apple.setName("紅蘋果")是會提示錯誤。

多態的實現：

1.用繼承設計進行設計

條件：繼承關系、重寫父類中的方法和隱式的向上轉型。
在之前的代碼，添加一個實體類Person,內部存在行為eat(Fruit fruit)方法。

class Person{
    public void eat(Fruit fruit){
        System.out.print("吃的");
        fruit.name();
    } 
}   
    public static void main(String[] arg0){
        Fruit apple = new Apple();
        Fruit banana = new Banana();
        Fruit orange = new Orange();
        
        Person july = new Person();
        july.eat(apple);
        july.eat(banana);
        july.eat(orange);
    }
輸出：
    吃的青蘋果
    吃的香蕉
    吃的橙子

可以看到并沒有使用eat(Apple apple)一類的方法，但也能正確的執行方法，我們不用為多帶帶的每個人創建類似于eatApple(Apple apple)這樣的方法，而且對于每一個繼承了Fruit類的水果類來說，都可以直接給person.eat(Fruit)調用。

2.用接口進行設計

條件：實現接口，并覆蓋其中的方法。

類似于使用繼承設計多態，接口設計如下所示：

public class FruitDemo implements IFruit{
    @Override
    public void name() {
        // TODO Auto-generated method stub
        System.out.println("水果");
    }
    public static void main(String[] arg0){
        AppleDemo apple = new AppleDemo();
        BananaDemo banana = new BananaDemo();
        PersonDemo july = new PersonDemo();
        july.eat(apple);
        july.eat(banana);
    }
}
class PersonDemo{
    public void eat(IFruit fruit){
        System.out.print("吃的");
        fruit.name();
    }
}
class AppleDemo implements IFruit{
    @Override
    public void name() {
        // TODO Auto-generated method stub
        System.out.println("蘋果");
    }
}
class BananaDemo implements IFruit{
    @Override
    public void name() {
        // TODO Auto-generated method stub
        System.out.println("香蕉");
    }
}
interface IFruit{
    void name();
}
    
輸出：
吃的蘋果
吃的香蕉

可以看到，程序中Person類實例july動態調用實現了IFruit接口的類，并且正確返回了信息。

多態特性之協變返回類型

子類方法的返回類型可以是父類方法的返回類型的子類。例如：

public class Fruit {

    public String name = "水果";
    public String getName(){
        System.out.println("fruit name --"+ name);
        return name;
    }
    
    public static void main(String[] arg0){
        Person person = new Person();
        person.buy().getName();
        
        Person man = new Man();
        man.buy().getName();
    } 
}


class Apple extends Fruit{
    public String name = "蘋果";
    public String getName(){
        System.out.println("apple name --"+ name);
        return name;
    }
}

class Person{
    public Fruit buy(){
        
        return new Fruit();
    }
}

class Man extends Person{
    public Apple buy(){
        return new Apple();
    }
}
輸出：
fruit name --水果
apple name --蘋果

在這里看到，子類Man中的方法，返回類型并不是Fruit，而是Fruit的子類，運行的也是子類Apple的方法。

多態存在的缺陷：

1.對私有方法和final修飾的方法無效。

public class Fruit {

    public void name(){
        System.out.println("水果");
    }
    
    public final void findName(){
        System.out.println("找水果");

    }
    
    private void getName(){
        System.out.println("拿水果");

    }
    
    public static void main(String[] arg0){
        Fruit apple = new Apple();
        apple.findName();
        apple.getName();
    } 
}
class Apple extends Fruit{
    
    public void getName(){
        System.out.println("拿到蘋果");

    }
    public void name(){
        System.out.println("青蘋果");
    }
    public void name(String name){
        System.out.println("蘋果設置成"+name);
    }
    
    public void setName(String name){
        System.out.println("蘋果設置成"+name);
    }
}
輸出：
     找水果
     拿水果

2.對父類字段和靜態方法無效。

public class Fruit {
    public String name = "水果";
    public String getName(){
        return name;
    }
    public static String getFruitName(){
        return "水果";
    }
    
    public static void main(String[] arg0){
        Fruit apple = new Apple();
        System.out.println("apple.name = "+apple.name+";apple.getName() = "+apple.getName());
        Apple apple1 = new Apple();
        System.out.println("apple1.name = "+apple1.name+";apple1.getName() = "+apple1.getName()+";apple1.getName1() = "+apple1.getName1());
        System.out.println("Fruit.getFruitName = "+ Fruit.getFruitName()+";Apple.getFruitName = "+Apple.getFruitName());

    } 
}
class Apple extends Fruit{
    public String name = "蘋果";
    public String getName(){
        return name;
    }
    public static String getFruitName(){
        return "蘋果";
    }
    public String getName1(){
        return super.name;
    }
}

輸出：
    apple.name = 水果;apple.getName() = 蘋果
    apple1.name = 蘋果;apple1.getName() = 蘋果;apple1.getName1() = 水果
    Fruit.getFruitName = 水果;Apple.getFruitName = 蘋果

可以看到 字段并不會覆蓋的，在子類Apple中是存在兩個name字段的，當使用Fruit apple引用時，apple.name使用的是父類Fruit中的字段，而當Apple apple1時，使用的是子類自己的字段。
靜態方法是不會有多態性的，它關聯的對象，而不是實例。

構造函數和多態：

構造函數執行的順序：
1.調用基類的構造器，這個順序會不斷遞歸下去，因為構造一個類，先構造基類，直到樹結構的最頂層。
2.按聲明順序調用成員的初始化方法。
3.調用導出類的構造器主體
構造器內部的多態方法：
如果一個構造方法的內部調用正在構造的對象的一個動態綁定方法，會發生什么情況？例如：

public class Fruit {
    public String name = "水果";
    public Fruit(){
        System.out.println("getName before--");
        System.out.println("getName--"+getName());
        System.out.println("getName after --");
    }
    public String getName(){
        return name;
    }
    public static void main(String[] arg0){
        Fruit apple =new Apple();
    } 
}
class Apple extends Fruit{
    public String name = "蘋果";
    public Apple(){
        System.out.println("Apple getName--"+getName());
    }
    public String getName(){
        return name;
    }
}

輸出：
getName before--
getName--null
getName after --
Apple getName--蘋果

可以看到，在結果中存在一個null值，如果當前屬性是基本數據類型，那么輸出的就是類型的初始默認值。之后會按照聲明順序來構造實例，所以后面得到的就是有值得了。

歡迎加入學習交流群569772982，大家一起學習交流。

。