多态進一步了解

多态中的成員通路特點：

        A:成員變量

            編譯看左邊，運作看左邊。

        B:構造方法

            建立子類對象的時候，通路父類的構造方法，對父類的資料進行初始化。

        C:成員方法

            編譯看左邊，運作看右邊。

        D:靜态方法

            編譯看左邊，運作看左邊。

            (靜态和類相關，算不上重寫，是以，通路還是左邊的)

/*
	多态練習：貓狗案例
*/
class Animal {
	public void eat(){
		System.out.println("吃飯");
	}
}

class Dog extends Animal {
	public void eat() {
		System.out.println("狗吃肉");
	}
	
	public void lookDoor() {
		System.out.println("狗看門");
	}
}

class Cat extends Animal {
	public void eat() {
		System.out.println("貓吃魚");
	}
	
	public void playGame() {
		System.out.println("貓捉迷藏");
	}
}

class DuoTaiTest {
	public static void main(String[] args) {
		//定義為狗
		Animal a = new Dog();
		a.eat();
		System.out.println("--------------");
		//還原成狗
		Dog d = (Dog)a;
		d.eat();
		d.lookDoor();
		System.out.println("--------------");
		//變成貓
		a = new Cat();
		a.eat();
		System.out.println("--------------");
		//還原成貓
		Cat c = (Cat)a;
		c.eat();
		c.playGame();
		System.out.println("--------------");
		
		//示範錯誤的内容
		//Dog dd = new Animal();
		//Dog ddd = new Cat();
		//ClassCastException
		//Dog dd = (Dog)a;
	}
}	
           

多态的問題了解：
	class 孔子爹 {
		public int age = 40;
		
		public void teach() {
			System.out.println("講解JavaSE");
		}
	}
	
	class 孔子 extends 孔子爹 {
		public int age = 20;
		
		public void teach() {
			System.out.println("講解論語");
		}
		
		public void playGame() {
			System.out.println("英雄聯盟");
		}
	}
	
	//Java教育訓練特别火,很多人來請孔子爹去講課，這一天孔子爹被請走了
	//但是還有人來請，就剩孔子在家，價格還挺高。孔子一想，我是不是可以考慮去呢?
	//然後就穿上爹的衣服，帶上爹的眼睛，粘上爹的胡子。就開始裝爹
	//向上轉型
	孔子爹 k爹 = new 孔子();
	//到人家那裡去了
	System.out.println(k爹.age); //40
	k爹.teach(); //講解論語
	//k爹.playGame(); //這是兒子才能做的
	
	
	//講完了，下班回家了
	//脫下爹的裝備，換上自己的裝備
	//向下轉型
	孔子 k = (孔子) k爹; 
	System.out.println(k.age); //20
	k.teach(); //講解論語
	k.playGame(); //英雄聯盟
	
           

/*
	多态的弊端：
		不能使用子類的特有功能。
		
	我就想使用子類的特有功能?行不行?
		行。
		
	怎麼用呢?
		A:建立子類對象調用方法即可。(可以，但是很多時候不合理。而且，太占記憶體了)
		B:把父類的引用強制轉換為子類的引用。(向下轉型)
		
	對象間的轉型問題：
		向上轉型：
			Fu f = new Zi();
		向下轉型：
			Zi z = (Zi)f; //要求該f必須是能夠轉換為Zi的。
*/
class Fu {
	public void show() {
		System.out.println("show fu");
	}
}

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

}

class DuoTaiDemo4 {
	public static void main(String[] args) {
		//測試
		Fu f = new Zi();
		f.show();
		//f.method();
		
		//建立子類對象
		//Zi z = new Zi();
		//z.show();
		//z.method();
		
		//你能夠把子的對象指派給父親，那麼我能不能把父的引用指派給子的引用呢?
		//如果可以，但是如下
		Zi z = (Zi)f;
		z.show();
		z.method();
	}
}
           

貓狗差別

/*
	ClassCastException:類型轉換異常
	一般在多态的向下轉型中容易出現
*/
class Animal {
	public void eat(){}
}

class Dog extends Animal {
	public void eat() {}
	
	public void lookDoor() {
	
	}
}

class Cat extends Animal {
	public void eat() {
	
	}
	
	public void playGame() {
		
	}
}

class DuoTaiDemo5 {
	public static void main(String[] args) {
		//記憶體中的是狗
		Animal a = new Dog();
		Dog d = (Dog)a;
		
		//記憶體中是貓
		a = new Cat();
		Cat c = (Cat)a;
		
		//記憶體中是貓
		Dog dd = (Dog)a; //ClassCastException
	}
}
           

/*
	多态練習：貓狗案例
*/
class Animal {
	public void eat(){
		System.out.println("吃飯");
	}
}

class Dog extends Animal {
	public void eat() {
		System.out.println("狗吃肉");
	}
	
	public void lookDoor() {
		System.out.println("狗看門");
	}
}

class Cat extends Animal {
	public void eat() {
		System.out.println("貓吃魚");
	}
	
	public void playGame() {
		System.out.println("貓捉迷藏");
	}
}

class DuoTaiTest {
	public static void main(String[] args) {
		//定義為狗
		Animal a = new Dog();
		a.eat();
		System.out.println("--------------");
		//還原成狗
		Dog d = (Dog)a;
		d.eat();
		d.lookDoor();
		System.out.println("--------------");
		//變成貓
		a = new Cat();
		a.eat();
		System.out.println("--------------");
		//還原成貓
		Cat c = (Cat)a;
		c.eat();
		c.playGame();
		System.out.println("--------------");
		
		//示範錯誤的内容
		//Dog dd = new Animal();
		//Dog ddd = new Cat();
		//ClassCastException
		//Dog dd = (Dog)a;
	}
}	
           

錯誤的内容是從右邊向左邊讀 動物是狗，貓是狗，明顯不對。運作的時候才有對象的存在。前面是編譯的錯誤後面是運作的錯誤。

不同地方飲食文化不同的案例

/*
	不同地方飲食文化不同的案例
*/
class Person {
	public void eat() {
		System.out.println("吃飯");
	}
}

class SouthPerson extends Person {
	public void eat() {
		System.out.println("炒菜,吃米飯");
	}
	
	public void jingShang() {
		System.out.println("經商");
	}
}

class NorthPerson extends Person {
	public void eat() {
		System.out.println("炖菜,吃饅頭");
	}
	
	public void yanJiu() {
		System.out.println("研究");
	}
}

class DuoTaiTest2 {
	public static void main(String[] args) {
		//測試
		//南方人
		Person p = new SouthPerson();
		p.eat();
		System.out.println("-------------");
		SouthPerson sp = (SouthPerson)p;
		sp.eat();
		sp.jingShang();
		System.out.println("-------------");
		
		//北方人
		p = new NorthPerson();
		p.eat();
		System.out.println("-------------");
		NorthPerson np = (NorthPerson)p;
		np.eat();
		np.yanJiu();
	}
}
           

/*
	看程式寫結果:先判斷有沒有問題，如果沒有，寫出結果
	
	多态的成員通路特點：
		方法：編譯看左邊，運作看右邊。
		
	繼承的時候：
		子類中有和父類中一樣的方法，叫重寫。
		子類中沒有父親中出現過的方法，方法就被繼承過來了。
*/
class A {
	public void show() {
		show2();
	}
	public void show2() {
		System.out.println("我");
	}
}
class B extends A {
	/*
	public void show() {
		show2();
	}
	*/

	public void show2() {
		System.out.println("愛");
	}
}
class C extends B {
	public void show() {
		super.show();
	}
	public void show2() {
		System.out.println("你");
	}
}
public class DuoTaiTest4 {
	public static void main(String[] args) {
		A a = new B();
		a.show();
		
		B b = new C();
		b.show();
	}
}