多型

所謂多型就是值程式中定義的引用變數所指向的具體型別和通過該引用變數發出的方法呼叫在程式設計時並不確定，而是在程式執行期間才確定，即一個引用變數倒底會指向哪個類的例項物件，該引用變數發出的方法呼叫到底是哪個類中是實現的方法，必須在由程式執行期間才能確定。因為在程式執行時才確定具體的類，這樣，不用修改源程式程式碼，就可以引用變數繫結到各種不同的類實現上，從而導致該引用呼叫的具體方法隨之改變，即不修改程式程式碼就可以改變程式執行時所繫結的具體程式碼，讓程式可以選擇多個執行狀態，這就是多型性   

多型：就是父類的引用指向子類的物件

多型的條件

1. 類與類之間存在繼承關係
2. 必須要有方法的重寫
3. 有父類的引用指向子類的物件

型別轉換

        向上轉型       自動完成
        向下轉型       強制轉換（在轉換之前需要使用  instanceof   來進行判斷）

當多型訪問成員變數的時候：
                                       如果子類和父類中都存在，訪問是父類

                                       如果要訪問子類中特有的成員變數：進行向下轉型。

當使用多型訪問成員方法的時候：
                                       如果子類重寫了父類的方法，訪問的是子類的
                                       如果要訪問子類中特有的成員方法：進行向下轉型。

使用多型訪問類中的成員（靜態和非靜態）
                                      成員變數：編譯看左邊，執行看左邊
                                      成員方法：編譯看左邊，執行看右邊
                          靜態的方法/變數：編譯看左邊，執行看左邊

相關程式碼示例  

public class Animal {
	private String name;
	int num = 10;
	static int a = 50;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	public static  void feed(){
		System.out.println("餵養食物");
		
	}
	public void showInfo() {
		System.out.println(this.name);
	}
}

public class Dog extends Animal{
		int num = 100;
		int num2 = 200;
		static int a = 500;
		public static  void feed() {
			
			System.out.println("骨頭....");
		}
		public void work() {
			
			System.out.println("狗看家....");
		}
}

public class Cat extends Animal {
	public static void feed() {
		
		System.out.println("吃魚.....");
	}
}

public class Person {
	/*public void feedDog(Dog d) {	
		d.feed();
			
	}
	public void feedCat(Cat c) {
		
		c.feed();
	}*/
	public void feedAnimal(Animal a) {
		
		a.feed();
	}
}

public class Test {
	public static void main(String[] args) {
		//1 建立一個飼養員
		Person p1 = new Person();
		// 2 建立一隻動物
		Dog d = new Dog();
		// 3 呼叫飼養員的餵養的方法  餵養動物
		//p1.feedDog(d);
		d.setName("旺財");
		p1.feedAnimal(d);// Animal a = new Dog()
		d.showInfo();
		Cat c = new Cat();
		//p1.feedCat(c);
		c.setName("Tom");
		c.showInfo();
		p1.feedAnimal(c);// Animal a = new Cat();
		
		
	}
}

public class Test2 {
	public static void main(String[] args) {
		//多型，當編譯的時候，此時a1 是animal的型別
		//只有到執行的時候，才會知道a1是一隻Dog
		Animal a1 = new Dog();
		Animal a2 = new Cat();
		a1.feed();
		//當我們使用了多型的時候，那麼就不能去呼叫子類特有的方法
		//a1.work();
		Dog d1 = new Dog();
		d1.work();
		//型別轉換：向上轉型/向下轉型
		/*
		 * 向上轉型可以自動完成
		 * 向下轉型：強制轉換
		 * byt b = （byte）i;
		 */
		Dog d2 = (Dog)a1;
		d2.work();
		//Cat c1 = (Cat)a1;
		// instanceOf 判斷某一個引用是否是一個類的例項物件
		if(a1 instanceof Dog) {
			
			Dog d3 = (Dog)a1;
			d3.work();
		}
		if(a1 instanceof Cat) {
			Cat c2 = (Cat) a1;
			
		}
		System.out.println("--------------------");
		System.out.println(a1.num);
		System.out.println(d2.num2);
		System.out.println(a1.a);
		System.out.println(d2.a);
		a1.feed();
		d2.feed();
	}
}