JAVA語言基礎-面向對象(多態）

• A:多態(polymorphic)概述
  • 事物存在的多種形態
• B:多態前提
  • a:要有繼承關係。
  • b:要有方法重寫。
  • c:要有父類引用指向子類對象。
• C:案例演示
  • 代碼體現多態      

class Demo1_Polymorphic {
	public static void main(String[] args) {
		Cat c = new Cat();
		c.eat();

		Animal a = new Cat();				//父類引用指向子類對象
		a.eat();
	}
}
/*
* A:多態(polymorphic)概述
	* 事物存在的多種形態 
* B:多態前提
	* a:要有繼承關係。
	* b:要有方法重寫。
	* c:要有父類引用指向子類對象。
* C:案例演示
	* 代碼體現多態
*/
class Animal {
	public void eat() {
		System.out.println("動物吃飯");
	}
}

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

09.02_面向對象(多態中的成員訪問特色)

• 成員變量
  • 編譯看左邊(父類)，運行看左邊(父類)。  
• 成員方法
  • 編譯看左邊(父類)，運行看右邊(子類)。也叫動態綁定       
• 靜態方法
  • 編譯看左邊(父類)，運行看左邊(父類)。
  • (靜態和類相關，算不上重寫，因此，訪問仍是左邊的)
  • 只有非靜態的成員方法,編譯看左邊,運行看右邊

class Demo2_Polymorphic {
	public static void main(String[] args) {
		/*Father f = new Son();					//父類引用指向子類對象
		System.out.println(f.num);

		Son s = new Son();
		System.out.println(s.num);*/

		Father f = new Son();
		//f.print();
		f.method();							//至關因而Father.method()
	}
}
/*
成員變量
編譯看左邊(父類),運行看左邊(父類)
成員方法
編譯看左邊(父類)，運行看右邊(子類)。動態綁定
靜態方法
編譯看左邊(父類)，運行看左邊(父類)。
(靜態和類相關，算不上重寫，因此，訪問仍是左邊的)
只有非靜態的成員方法,編譯看左邊,運行看右邊 
*/
class Father {
	int num = 10;
	public void print() {
		System.out.println("father");
	}

	public static void method() {
		System.out.println("father static method");
	}
}

class Son extends Father {
	int num = 20;

	public void print() {
		System.out.println("son");
	}

	public static void method() {
		System.out.println("son static method");
	}
}

面向對象(超人的故事)

• A:案例分析  

class Demo3_SuperMan {
	public static void main(String[] args) {
		Person p = new SuperMan();			//父類引用指向子類對象,超人提高爲了人
											//父類引用指向子類對象就是向上轉型
		System.out.println(p.name);
		p.談生意();
		SuperMan sm = (SuperMan)p;			//向下轉型
		sm.fly();

		/*
		基本數據類型自動類型提高和強制類型轉換
		*/
		int i = 10;
		byte b = 20;
		//i = b;						//自動類型提高
		//b = (byte)i;					//強制類型轉換
	}
}

class Person {
	String name = "John";
	public void 談生意() {
		System.out.println("談生意");
	}
}

class SuperMan extends Person {
	String name = "superMan";

	public void 談生意() {
		System.out.println("談幾個億的大單子");
	}

	public void fly() {
		System.out.println("飛出去救人");
	}
}

09.06_面向對象(多態中向上轉型和向下轉型)

• A:案例演示
  • 詳細講解多態中向上轉型和向下轉型 Person p = new SuperMan();向上轉型 SuperMan sm = (SuperMan)p;向下轉型

            

09.07_面向對象(多態的好處和弊端)

• A:多態的好處
  • a:提升了代碼的維護性(繼承保證)
  • b:提升了代碼的擴展性(由多態保證)
• B:案例演示
  • 多態的好處
  • 能夠看成形式參數,能夠接收任意子類對象
• C:多態的弊端
  • 不能使用子類的特有屬性和行爲。
• D:案例演示 method(Animal a) method(Cat c)   

class Demo4_Animal {
	public static void main(String[] args) {
		//Cat c1 = new Cat();
		//c1.eat();
		method(new Cat());
		method(new Dog());

		//Animal a = new Cat();			開發的是不多在建立對象的時候用父類引用指向子類對象,直接建立子類對象更方便,能夠使用子類中的特有屬性和行爲
	}
	
	//Cat c = new Dog();狗是一隻貓,這是錯誤的
	/*public static void method(Cat c) {			
		c.eat();
	}

	public static void method(Dog d) {
		d.eat();
	}*/
	
	//若是把狗強轉成貓就會出現類型轉換異常,ClassCastException
	public static void method(Animal a) {	//看成參數的時候用多態最好,由於擴展性強
		//關鍵字 instanceof 判斷前邊的引用是不是後邊的數據類型
		if (a instanceof Cat) {
			Cat c = (Cat)a;
			c.eat();
			c.catchMouse();
		}else if (a instanceof Dog) {
			Dog d = (Dog)a;
			d.eat();
			d.lookHome();
		}else {
			a.eat();
		}
	}
}
/*
* A:多態的好處
	* a:提升了代碼的維護性(繼承保證)
	* b:提升了代碼的擴展性(由多態保證)
* B:案例演示
	* 多態的好處
	* 能夠看成形式參數,能夠接收任意子類對象
* C:多態的弊端
	* 不能使用子類的特有屬性和行爲。
*/

class Animal {
	public void eat() {
		System.out.println("動物吃飯");
	}
}

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 lookHome() {
		System.out.println("看家");
	}
}

09.08_面向對象(多態中的題目分析題)

• A:看下面程序是否有問題，若是沒有，說出結果

• class Fu {
      public void show() {
          System.out.println("fu show");
      }
  }
  
  class Zi extends Fu {
      public void show() {
          System.out.println("zi show");
      }
  
      public void method() {
          System.out.println("zi method");
      }
  }
  
  class Test1Demo {
      public static void main(String[] args) {
          Fu f = new Zi();
          f.method();
          f.show();
      }
  }

• B:看下面程序是否有問題，若是沒有，說出結果

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