多型

要用到多型，一定是已經有子父類關係或者類實現介面等前提

格式：

父類型別 變數名稱 = new 子型別行（）； 變數名稱.方法（）；

具體體現（父子類，抽象類，介面）

class Fu {}class Zi extends Fu { public void method(){ System.out.println(“重寫父類抽象方法”);} }//類的多型使用 Fu f = new Zi();//這其實就是向上轉型

abstract class Fu {
         public abstract void method();
	     }
class Zi extends Fu {
public void method(){
        System.out.println(“重寫父類抽象方法”);
}
}
//類的多型使用
Fu fu= new Zi();   //父類 變數名稱 = new 子類();

interface Fu {
		     public abstract void method();
}
class Zi implements Fu {
		     public void method(){
              System.out.println(“重寫介面抽象方法”);
}
}
//介面的多型使用
Fu fu = new Zi();   //介面 變數名稱 = new 介面實現類()
 
；

另外，父類被不同子類的同名方法重寫，執行的方法看子類重寫的步驟，下面是理解方式：

   Person p1 = new xiaoxuesheng();
   Person p2 = new daxuesheng();
   p1.work(); //p1會呼叫xiaoxuesheng類中重寫的work方法,可能是背古詩，看子類重寫方法是什麼
   p2.work(); //p2會呼叫daxuesheng類中重寫的work方法，可能是敲程式碼，看子類重寫方法是什麼

多型框架下的兩條規則：

多型的成員變數編譯和執行依據父類（new等式的左邊） 多型的成員方法編譯看左邊（編譯中父類必須重寫方法），執行看右邊（執行過程中如果子父類方法同名，執行子類）

class Fu {
	int i = 1;
}
class Zi extends Fu {
	int i = 2;
}
class Demo {
	public static void main(String[] args) 	{
		Fu f = new Zi();
		System.out.println(f.i); //1
		Zi z = new Zi();
		System.out.println(z.i);  //2
	}
}
 

class Fu {
	int i = 1;
	void func()	{
		System.out.println("Fu");
	}
}
class Zi extends Fu {
	int i = 2;
	void func()	{
		System.out.println("Zi");
	}
}
class Demo {
	public static void main(String[] args) 	{
		Fu f = new Zi();
		f.show();  //Zi
	}
}

instanceof關鍵字，用於判斷物件是否屬於某種型別，會基於返回值true or false 使用格式：boolean a = 物件名稱 instanceof 資料型別；

profession a = new Doctor();
boolean i = a instanceof Worker; //false
boolean i = a instanceof Doctor; //true 

向下轉型

父類型別  變數名 = new 子類型別();
如：Person p = new Doctor();
子類型別 變數名 = (子類型別) 父類型別的變數;
如:Doctor nur = (Doctor) p;  

考慮到靜態呼叫，總體來說：編譯都看左邊的父類 執行若是靜態方法，執行父類中的靜態方法（靜態方法是類 不是物件，不屬於多型範疇） 執行若是非靜態方法，執行子類重寫方法， 對於成員變數，編譯執行全看父類！