概述

多型是繼封裝、繼承之後，面向物件的第三大特性。

多型: 是指同一行為，具有多個不同表現形式。

1. 繼承或者實現【二選一】
2. 方法的重寫【意義體現:不重寫，無意義】
3. 父類引用指向子類物件【格式體現】

多型的體現

多型體現的格式:

父類型別 變數名 = new 子類物件; 
變數名.方法名();
tips:父類型別:指子類物件繼承的父類型別，或者實現的父介面型別。

#程式碼如下
Fu f = new Zi(); 
f.method()

當使用多型方式呼叫方法時，首先檢查父類中是否有該方法，如果沒有，則編譯錯誤;如果有，執行的是子類重寫
後方法

// 定義父類
  public abstract class Animal { 
		public abstract void eat();
}



// 定義子類
  class Cat Extends Animal{
    public void eat(){
       System.out.println("吃魚");
    }
  }

	class Dog Extends Animal{
  	public void eat(){
    	System.out.println("吃骨頭");
  	}
	}


// 定義測試類
  public class Test{
    public static void main(String[] args){
      //多型形式，建立物件
      Animal a1 = new Cat();
      //呼叫的是Cat的eat
      a1.eat();
      
      //多型形式，建立物件
      Animal a2 = new Dog();
      //呼叫的是Dog的eat
      a2.eat();
    }
  }
 
 

多型的好處

實際開發的過程中，父類型別作為方法形式引數，傳遞子類物件給方法，進行方法的呼叫，更能體現出多型的擴充套件性與便利

//定義父類
 public abstract class Animal { 
   public abstract void eat();
}


//定義子類
 class Cat extends Animal { 
   public void eat() {
		System.out.println("吃魚"); }
}
 class Dog extends Animal { 
   public void eat() {
		System.out.println("吃骨頭"); }
}


//定義測試類
public class test3 {
    public static void main(String[] args) {
        // 多型形式，建立物件
        Cat c = new Cat();
        Dog d = new Dog();
        // 呼叫showCatEat
        showCatEat(c);
        // 呼叫showDogEat
        showDogEat(d);
        //以上兩個方法, 均可以被showAnimalEat(Animal a)方法所替代 而執行效果一致
        showAnimalEat(c);
        showAnimalEat(d);
    }
    public static void showCatEat(Cat c) {
        c.eat();
    }
    public static void showDogEat(Dog d) {
        d.eat();
    }
    public static void showAnimalEat(Animal a) {
        a.eat();
    }
}

/*
由於多型特性的支援，showAnimalEat方法的Animal型別，是Cat和Dog的父類型別，父類型別接收子類物件，當 然可以把Cat物件和Dog物件，傳遞給方法。
當eat方法執行時，多型規定，執行的是子類重寫的方法，那麼效果自然與showCatEat、showDogEat方法一致， 所以showAnimalEat完全可以替代以上兩方法。*/
 

引用型別轉換

向上轉型

向上轉型:多型本身是子類型別向父類型別向上轉換的過程，這個過程是預設的。當父類引用指向一個子類物件時，便是向上轉型。

父類型別 變數名 = new 子類型別(); 
如:Animal a = new Cat();

向下轉型

向下轉型:父類型別向子類型別向下轉換的過程，這個過程是強制的。一個已經向上轉型的子類物件，將父類引用轉為子類引用，可以使用強制型別轉換的格式，便是向下轉型。

子類型別 變數名 = (子類型別) 父類變數名; 
如:Cat c =(Cat) a;

為什麼要轉型

當使用多型方式呼叫方法時，首先檢查父類中是否有該方法，如果沒有，則編譯錯誤。也就是說，不能呼叫子類擁有，而父類沒有的方法。

理解：想直接呼叫子類中定義，而父類中沒有的方法。該方法子類獨有，需要進行向下轉型。

//定義類
abstract class Animal {
    abstract void eat();
}

class Cat extends Animal {
    public void eat() {
        System.out.println("吃魚");
    }
    public void catchMouse() {
        System.out.println("抓老鼠");
    }
}

class Dog extends Animal {
    public void eat() {
        System.out.println("吃骨頭");
    }
    public void watchHouse() {
        System.out.println("看家");
    }
}


//定義測試類
public class Test {
    public static void main(String[] args) {
        // 向上轉型
        Animal a = new Cat();
        a.eat();
        // 向下轉型
        if (a instanceof Cat) {
            Cat c = (Cat) a;
            // 呼叫的是 Cat 的 eat
            // 呼叫的是 Cat 的 catchMouse d.watchHouse(); // 呼叫的是 Dog 的 watchHouse
            c.catchMouse();
        } else if (a instanceof Dog) {
            Dog d = (Dog) a;
            d.watchHouse();
        }
    }
}