java多型特性

多型:用父類的引用指向子類的物件

package com.qianfeng.test;

/*

• 多型:一種事物的多種形態 狗 == 動物 == 生物 學生 == 高階動物 == 動物 == 生物

• 多型的前提:類與類之間一定要有繼承的關係
  */
  public class Demo6 {

  public static void main(String[] args) {

   // 使用繼承--使用子類的引用工作
   Dog dog = new Dog();
   dog.play();// 呼叫父類的方法
   dog.show();// 呼叫自己的方法
  
   // 多型:用父類的引用指向子類的物件
   // 注意:這裡說的父類不是單指直接的父類,只要是父類即可
   Animal animal = new Dog();
   /*
    * 一個程式執行的時候分成三個階段: 預編譯:程式開啟的時候,活兒已經幹完了. (預處理命令 #define)
    * 編譯:從開啟程式開始到點選左上角的三角之前的階段.----只會識別=前面的引用型別,不會去識別=後面的物件.
    * 執行:從點選三角開始.----這裡才會去真正識別=後面的物件.
    */
   animal.play();
   // animal.show();//呼叫方法的工作機制:1.首先由animal找到Dog物件,Dog物件再去呼叫show方法
   // 不能通過的原因:在編譯的時候識別的是引用型別,不識別物件.所以只能識別出animal特有的方法,不能呼叫子類特有的方法.
  
   /*
    * 優點:可以提高程式碼的擴充套件性,使用之前定義好的功能,後面直接拿來使用,而不用再去建立新的方法.解釋在Demo7
    * 缺點:不能直接呼叫子類特有的方法,只能呼叫父類有的方法
    */
  

  }
  }

class Animal {
String name;

public Animal(String name) {
	super();
	this.name = name;
}

public Animal() {
	super();
	// TODO Auto-generated constructor stub
}

public void play() {
	System.out.println("Animal-play");
}

}

class Dog extends Animal {

public void show() {
	System.out.println("Dog-show");
}

}

class Cat extends Animal {

public void eat() {
	System.out.println("Cat-eat");
}

}

---

多型的優點:可以提高程式碼的擴充套件性,使用之前定義好的功能,後面直接拿來使用,而不用再去建立新的方法。

package com.qianfeng.test;

/*

• 優點:可以提高程式碼的擴充套件性,使用之前定義好的功能,後面直接拿來使用,而不用再去建立新的方法.解釋在Demo7
  */
  public class Demo7 {

  public static void main(String[] args) {

   Dog1 dog1 = new Dog1();
   Cat1 cat1 = new Cat1();
   Animal1 animal1 = new Animal1();
  
   // feedDog(dog1);
   // feedCat(cat1);
   feedAnimal(dog1);
   feedAnimal(cat1);
   feedAnimal(animal1);
  

  }

  public static void feedAnimal(Animal1 animal) {// animal = dog1 = new Dog1()
  //多型

   animal.eat();
  

  }

  // public static void feedDog(Dog1 dog1) {
  // dog1.eat();
  // }
  //
  // public static void feedCat(Cat1 cat1) {
  // cat1.eat();
  // }
  }

class Animal1 {
String name;

public Animal1(String name) {
	super();
	this.name = name;
}

public Animal1() {
	super();
	// TODO Auto-generated constructor stub
}

public void play() {
	System.out.println("Animal1-play");
}

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

}

class Dog1 extends Animal1 {

public void show() {
	System.out.println("Dog1-show");
}

public void eat() {
	System.out.println("狗吃");
}

}

class Cat1 extends Animal1 {

public void eat() {
	System.out.println("Cat1-eat");
}

}

---

向上轉型與向下轉型

package com.qianfeng.test;

/*

• 前提:這裡一定是多型
• 父類的型別比子類的型別等級高
• 向上轉型:相當於自動型別轉換,由低型別到高型別

•  	注意:是將子類的引用轉成父類的引用,但是隻是將=前面進行轉換,與=後面無關
  

• 向下轉型:相當於強制型別轉換,由高型別到低型別

•  	注意:是將父類的引用強制轉換成子類的引用.
  

*/
public class Demo8 {

public static void main(String[] args) {

	// 向上轉型
	Animal2 animal2 = new Dog2();// 多型

	// 向下轉型--為了呼叫子類特有的方法
	Dog2 dog2 = (Dog2) animal2;
	dog2.show();// 呼叫子類特有方法

	// 注意點:
	// 1.這裡不叫向上轉型,這是錯誤.不能使用子類的引用指向父類的物件.
	// Dog2 dog22 = new Animal2();

	// 2.這裡不是多型,所以不是向下轉型,向下轉型的前提是多型
	Animal2 animal22 = new Animal2();
	Dog2 dog22 = (Dog2) animal22;
}

}

class Animal2 {

String name;
public Animal2(String name) {
	super();
	this.name = name;
}

public Animal2() {
	super();
	// TODO Auto-generated constructor stub
}

public void play() {
	System.out.println("Animal2-play");
}

}

class Dog2 extends Animal2 {

public void show() {
	System.out.println("Dog2-show");
}

}

class Cat2 extends Animal2 {

public void eat() {
	System.out.println("Cat2-eat");
}

}

---

intstanceof關鍵字

package com.qianfeng.test;

public class Demo9 {

public static void main(String[] args) {

	Dog3 dog3 = new Dog3();
	Cat3 cat3 = new Cat3();

	feedAnimal(cat3);
}

public static void feedAnimal(Animal3 animal3) {// animal3 = dog3 = new
												// Dog3() 多型
	// animal3.eat();

	// 容錯處理:包容這塊出錯的程式碼,不讓他影響後面正常程式碼的執行-----增加使用者體驗
	// intstanceof本身是一個運算子.構成: 物件 instanceof 類 ,作用:確定前面的物件是否是後面的類或子類的物件
	// 返回值有兩個:如果是返回true
	// 不是:返回false
	// 注意點:
	// 1.instanceof前後必須有繼承關係
	if (!(animal3 instanceof Dog3)) {
		System.out.println("傳入的物件不是Dog3或子類的物件");
		System.exit(0);// 退出程式
	}

	// 向下轉型
	Dog3 dog3 = (Dog3) animal3;
	dog3.show();// 呼叫子類特有的方法

	System.out.println("繼續");

}

}

class Animal3 {

String name;
public Animal3(String name) {
	super();
	this.name = name;
}

public Animal3() {
	super();
	// TODO Auto-generated constructor stub
}

public void play() {
	System.out.println("Animal3-play");
}

public void eat() {
	System.out.println("animal-eat");
}

}

class Dog3 extends Animal3 {

public void show() {
	System.out.println("Dog3-show");
}

public void eat() {
	System.out.println("Dog3-eat");
}

}

class Cat3 extends Animal3 {

public void eat() {
	System.out.println("Cat3-eat");
}

}

---

成員在多型下的使用

package com.qianfeng.test;

/*
*成員在多型下的使用
*/
public class Demo10 {

public static void main(String[] args) {

	// 繼承中成員的使用
	Zi zi = new Zi();
	System.out.println(zi.age);// 3 ,說明在繼承下,子類的優先

	/*
	 * 多型下 當父類與子類定義了同名的屬性:成員變數編譯的時候看父類,執行的時候還是看父類 成員方法:編譯的時候看父類,執行的時候看子類
	 * 靜態的成員方法:編譯執行都看父類
	 */
	Fu fu = new Zi();
	System.out.println(fu.age);// 5
	fu.eat();
	Fu.play();
}

}

class Fu {
int age = 5;

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

public static void play() {
	System.out.println("Fu-play");
}

}

class Zi extends Fu {
int age = 3;

public void show() {
	System.out.println("Zi-show");
}

public static void play() {
	System.out.println("Zi-play");
}

}