【Java】Java進階學習筆記（三）—— 面向對象（多态）

一、多态的概念
- 1、多态的優點
- 2、多态存在的三個必要條件
- 3、多态中的成員特點
- 4、重寫方法的快捷鍵
二、多态的轉型
- - 1、向上轉型
  - 2、向下轉型
  - 3、代碼示例
  - 4、轉型的異常
  - - 類型轉換異常
    - instanceof 比較操作符
  - 5、動态綁定
三、多态執行個體
- 1、多态的使用
- 2、多态數組
- 3、多态參數
四、多态的實作方式
- - 方式一：重寫
  - 方式二：接口
  - 方式三：抽象類和抽象方法

一、多态的概念

多态是同一個行為具有多個不同表現形式或形态的能力。

多态就是同一個接口，使用不同的執行個體而執行不同操作，如圖所示：

【Java】Java進階學習筆記（三）—— 面向對象（多态）一、多态的概念二、多态的轉型三、多态執行個體四、多态的實作方式

多态性是對象多種表現形式的展現。

1、多态的優點

1. 消除類型之間的耦合關系；
2. 可替換性；
3. 可擴充性：定義方法的時候，使用父類類型作為參數，将來使用時，**使用具體的子類類型操作**
4. 接口性；
5. 靈活性：無論右邊new的時候換成哪個子類對象，等号左邊調用方法都不會變化。
6. 簡化性

2、多态存在的三個必要條件

繼承：在多态中必須存在有繼承或實作關系的子類和父類；
方法的重寫：子類對父類中的某些方法進行重新定義（重寫，使用@Override注解進行重寫）
父類引用指向子類對象： Parent p = new Child() ;

【Java】Java進階學習筆記（三）—— 面向對象（多态）一、多态的概念二、多态的轉型三、多态執行個體四、多态的實作方式

class Shape {
    void draw() {}
}
 
class Circle extends Shape {
    void draw() {
        System.out.println("Circle.draw()");
    }
}
 
class Square extends Shape {
    void draw() {
        System.out.println("Square.draw()");
    }
}
 
class Triangle extends Shape {
    void draw() {
        System.out.println("Triangle.draw()");
    }
}

當使用多态方式調用方法時，首先檢查父類中是否有該方法，如果沒有，則編譯錯誤；如果有，再去調用子類的同名方法。

多态的好處：可以使程式有良好的擴充，并可以對所有類的對象進行通用處理。

以下是一個多态執行個體的示範，詳細說明請看注釋：

public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 對象調用 show 方法
      show(new Dog());  // 以 Dog 對象調用 show 方法
                
      Animal a = new Cat();  // 向上轉型  
      a.eat();               // 調用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下轉型  
      c.work();        // 調用的是 Cat 的 work
  }  
            
    public static void show(Animal a)  {
      a.eat();  
        // 類型判斷
        if (a instanceof Cat)  {  // 貓做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃魚");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨頭");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

執行以上程式，輸出結果為：

吃魚
抓老鼠
吃骨頭
看家
吃魚
抓老鼠

3、多态中的成員特點

多态成員方法：

編譯看左邊，運作看右邊

此處舉例Animal是父類，Dog是子類

Animal  dog  =  new Dog（）；  //Animal是引用類型，Dog是實際類型
dog.eat();     //變量dog的實際類型是Dog,即是由Dog 這個實際類型new出來的，是以dog.eat() 調用的應該是子類Dog中重寫的方法

4、重寫方法的快捷鍵

在子類Dog中右鍵選擇 Generate

【Java】Java進階學習筆記（三）—— 面向對象（多态）一、多态的概念二、多态的轉型三、多态執行個體四、多态的實作方式

2. 選擇Override Methods然後點選生成

【Java】Java進階學習筆記（三）—— 面向對象（多态）一、多态的概念二、多态的轉型三、多态執行個體四、多态的實作方式

二、多态的轉型

1、向上轉型

本質：

父類的引用指向子類的對象
特點：

（1）編譯類型看左邊，運作類型看右邊；

（2）可以調用父類的所有成員（需遵守通路權限）；

（3）不能調用子類的特有成員；

（4）運作效果看子類的具體實作。
文法：

2、向下轉型

本質：

一個已經向上轉型的子類對象，将父類引用轉為子類引用。

特點：

（1）隻能強制轉換父類的引用，不能強制轉換父類的對象；

（2）要求父類的引用必須指向的是目前目标類型的對象；

（3）當向下轉型後，可以調用子類類型中所有的成員。
文法：

子類類型 引用名 = (子類類型) 父類引用;
//用強制類型轉換的格式，将父類引用類型轉為子類引用類型

3、代碼示例

說明：

定義一個 Person 類 作為父類，定義 Student 類 和 Teacher 類作為子類繼承父類；
Person 類 擁有 mission() 方法；
Student 類 和 Teacher 類 重寫父類的 mission() 方法 并且 分别擁有各自的特有的 score() 方法 和 salary() 方法；
最後在 main 函數中 示範轉型。

代碼如下：

（1）定義類：

package Poly_;

public class Person {
	public void mission() {	
		System.out.println("人要好好活着！");
	}
}

class Student extends Person {	
	@Override
	public void mission() {	
		System.out.println("學生要好好學習！");
	}
	
	public void score() {
		System.out.println("學生得到好成績！");
	}
}

class Teacher extends Person {
	@Override
	public void mission() {	
		System.out.println("老師要好好教書！");
	}
	
	public void salary() {	
		System.out.println("老師得到高工資！");
	}
}

（2）在 Test02 類中編寫 main 函數，示範轉型

package Poly_;

//轉型示範
public class Test02 {
	public static void main(String[] args) {
		//向上轉型（自動類型轉換）
		Person p1 = new Student();
		
		//調用的是 Student 的 mission
		p1.mission(); 
		
		//向下轉型
		Student s1 = (Student)p1;
		
		//調用的是 Student 的 score
		s1.score();
	}
}

（3）運作結果：

學生要好好學習！
學生得到好成績！

4、轉型的異常

類型轉換異常

說明：使用強轉時，可能出現異常，對2.3代碼示例中的 Test02類重新編寫，示範轉型異常。

代碼如下：

//異常示範
public class Test02 {
	public static void main(String[] args) {
		//向上轉型
		Person p1 = new Student();
		
		//調用的是 Student 的 mission
		p1.mission(); 
		
		//向下轉型
		Teacher t1 = (Teacher) p1;
		
		//運作時報錯
		p1.salary();
	}
}

解釋：這段代碼在運作時出現了 ClassCastException 類型轉換異常，原因是 Student 類與 Teacher 類沒有繼承關系，是以所建立的是Student 類型對象在運作時不能轉換成 Teacher 類型對象。

instanceof 比較操作符

為了避免上述類型轉換異常的問題，我們引出 instanceof 比較操作符，用于判斷對象的類型是否為XX類型或XX類型的子類型。

格式：對象 instanceof 類名稱
解釋：這将會得到一個boolean值結果，也就是判斷前面的對象能不能當作後面類型的執行個體

代碼示例：

package Poly_;

//示範 instanceof 的使用
public class Test03 {
	public static void main(String[] args) {
		//向上轉型
		Person p1 = new Student();
		
		//調用的是 Student 的 mission
		p1.mission();
		
		//向下轉型
		//利用 instanceof 進行判斷
		if(p1 instanceof Student) {	//判斷對象 p1 是否是 Student 類 的執行個體
			Student s1 = (Student)p1;
			s1.score();  //調用的是 Student 的 score
			//上面這兩句也可簡寫為 ((Student) p1).score();
		}
		else if(p1 instanceof Teacher){ //判斷對象 p1 是否是 Teacher 類 的執行個體
			Teacher t1 = (Teacher)p1;
			t1.salary(); //調用的是 Teacher 的 salary
			//同理，上面這兩句也可簡寫為 ((Teacher) p1).salary();
		}
	}
}

運作結果：

學生要好好學習！
學生得到好成績！

5、動态綁定

當調用對象方法的時候，該方法會和該對象的運作類型綁定
當調用對象屬性時，沒有動态綁定機制，即哪裡聲明，哪裡使用。

代碼示例：

package dynamic_;

//示範動态綁定
public class DynamicBinding {
	public static void main(String[] args) {
		//向上轉型（自動類型轉換）
		//程式在編譯階段隻知道 p1 是 Person 類型
		//程式在運作的時候才知道堆中實際的對象是 Student 類型	
		Person p1 = new Student();  
		
		//程式在編譯時 p1 被編譯器看作 Person 類型
		//是以編譯階段隻能調用 Person 類型中定義的方法
		//在編譯階段，p1 引用綁定的是 Person 類型中定義的 mission 方法（靜态綁定）
		//程式在運作的時候，堆中的對象實際是一個 Student 類型，而 Student 類已經重寫了 mission 方法
		//是以程式在運作階段對象中綁定的方法是 Student 類中的 mission 方法（動态綁定）
		p1.mission();
	}
}

//父類
class Person {
	public void mission() {	
		System.out.println("人要好好活着！");
	}
}

//子類
class Student extends Person {
	@Override
	public void mission() {	
		System.out.println("學生要好好學習！");
	}
}

三、多态執行個體

1、多态的使用

/* 檔案名 : Employee.java */
public class Employee {
   private String name;
   private String address;
   private int number;
   public Employee(String name, String address, int number) {
      System.out.println("Employee 構造函數");
      this.name = name;
      this.address = address;
      this.number = number;
   }
   public void mailCheck() {
      System.out.println("郵寄支票給： " + this.name
       + " " + this.address);
   }
   public String toString() {
      return name + " " + address + " " + number;
   }
   public String getName() {
      return name;
   }
   public String getAddress() {
      return address;
   }
   public void setAddress(String newAddress) {
      address = newAddress;
   }
   public int getNumber() {
     return number;
   }
}

假設下面的類繼承Employee類：

/* 檔案名 : Salary.java */
public class Salary extends Employee
{
   private double salary; // 全年工資
   public Salary(String name, String address, int number, double salary) {
       super(name, address, number);
       setSalary(salary);
   }
   public void mailCheck() {
       System.out.println("Salary 類的 mailCheck 方法 ");
       System.out.println("郵寄支票給：" + getName()
       + " ，工資為：" + salary);
   }
   public double getSalary() {
       return salary;
   }
   public void setSalary(double newSalary) {
       if(newSalary >= 0.0) {
          salary = newSalary;
       }
   }
   public double computePay() {
      System.out.println("計算工資，付給：" + getName());
      return salary/52;
   }
}

測試代碼

/* 檔案名 : VirtualDemo.java */
public class VirtualDemo {
   public static void main(String [] args) {
      Salary s = new Salary("員工 A", "北京", 3, 3600.00);
      Employee e = new Salary("員工 B", "上海", 2, 2400.00);
      System.out.println("使用 Salary 的引用調用 mailCheck -- ");
      s.mailCheck();
      System.out.println("\n使用 Employee 的引用調用 mailCheck--");
      e.mailCheck();
    }
}

以上執行個體編譯運作結果如下：

Employee 構造函數
Employee 構造函數
使用 Salary 的引用調用 mailCheck -- 
Salary 類的 mailCheck 方法 
郵寄支票給：員工 A ，工資為：3600.0

使用 Employee 的引用調用 mailCheck--
Salary 類的 mailCheck 方法 
郵寄支票給：員工 B ，工資為：2400.0

例子解析

執行個體中，執行個體化了兩個 Salary 對象：一個使用 Salary 引用 s，另一個使用 Employee 引用 e。

當調用 s.mailCheck() 時，編譯器在編譯時會在 Salary 類中找到 mailCheck()，執行過程 JVM 就調用 Salary 類的 mailCheck()。

e 是 Employee 的引用，但引用 e 最終運作的是 Salary 類的 mailCheck() 方法。

在編譯的時候，編譯器使用 Employee 類中的 mailCheck() 方法驗證該語句， 但是在運作的時候，Java虛拟機(JVM)調用的是 Salary 類中的 mailCheck() 方法。

以上整個過程被稱為虛拟方法調用，該方法被稱為虛拟方法。

Java中所有的方法都能以這種方式表現，是以，重寫的方法能在運作時調用，不管編譯的時候源代碼中引用變量是什麼資料類型。

2、多态數組

多态數組：數組的定義類型為父類類型，裡面儲存的實際元素類型為子類類型。

代碼示例：（循環調用基類對象，通路不同派生類的方法）

說明：

定義一個 Person 類 作為父類，定義 Student 類 和 Teacher 類 作為子類繼承父類；
Person 類 擁有 name(姓名) 屬性 以及 mission() 方法；
Student 類 和 Teacher 類 擁有各自特有的 score 和 salary 屬性,，除此之外，重寫父類的 mission() 方法 ；
要求：最後在 main 函數中 建立一個 Person 對象 、一個 Student 對象 和 一個 Teacher 對象，統一放在數組裡，并調用每個對象的 mission() 方法。

代碼如下：

（1）父類 Person 類：

package polyarr;

public class Person {
	private String name;
	
	public Person(String name) {
		this.name = name;
	}
	
	// getter 和 setter
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

	// mission() 方法
	public String mission() {	
		return name + "\t" + "要好好活着";
	}
}

（2）子類 Student 類

package polyarr;

public class Student extends Person {
	private double score;

	public Student(String name, double score) {
		super(name);
		this.score = score;
	}

	public double getScore() {
		return score;
	}

	public void setScore(double score) {
		this.score = score;
	}
	
	//重寫父類的say方法
	@Override
	public String mission() {	
		return super.mission() + " score =" + score + " 要好好學習！";
	}
}

（3）子類 Teacher 類

package polyarr;

public class Teacher extends Person {
	private double salary;

	public Teacher(String name, double salary) {
		super(name);
		this.salary = salary;
	}

	public double getSalary() {
		return salary;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}
	
	//重寫父類的 mission 方法
	@Override
	public String mission() {	
		return super.mission() + " salary =" + salary + " 要好好教書！";
	}
}

（4）PolyArray 類中編寫 main 函數

package polyarr;

/*
 * 示範多态數組
 * 建立一個 Person 對象 
 * 建立一個 Student 對象 
 * 建立一個 Teacher 對象
 * 統一放在數組裡，并調用每個對象的 mission() 方法。
 */
public class PolyArray {
	public static void main(String[] args) {
		Person[] persons = new Person[3];
		persons[0] = new Person("小湯");
		persons[1] = new Student("小韬", 100);
		persons[2] = new Teacher("小蒲", 10000);
		
		//循環周遊多态數組，調用 mission
		for(int i = 0; i < persons.length; i++) {
			//此處涉及動态綁定機制
			// Person[i] 編譯類型是 Person ,運作類型根據實際情況由 JVM 判斷
			System.out.println(persons[i].mission());  
		}
	}
}

（5）運作結果：

小湯	要好好活着！
小韬	要好好活着！ score = 100.0 要好好學習！
小蒲	要好好活着！ salary = 10000.0 要好好教書！

3、多态參數

多态參數：方法定義的形參類型為父類類型，實參類型允許為子類類型。

代碼示例：

說明：

定義一個 Person 類 作為父類，定義 Student 類 和 Teacher 類作為子類繼承父類；
Person 類 擁有 name(姓名) 屬性
Student 類 和 Teacher 類 擁有各自 特有 的 study() 和 teach() 方法 ；
要求：最後在 main 函數中 編寫 test() 方法 ，功能是調用 Student 類 的 study() 或 Teacher 類 的 teach() 方法，用于示範 多态參數 的使用。

代碼如下：

package polyparameter;

//示範多态參數
public class PolyParameter { 
	public static void main(String[] args) {
		Student s1 = new Student("小藍同學");
		Teacher t1 = new Teacher("小綠老師");
		
		//需先 new 一個目前類的執行個體化，才能調用 test 方法
		PolyParameter polyParameter = new PolyParameter();
		
		//實參是子類
		polyParameter.test(s1);
		polyParameter.test(t1);		
	}

	//定義方法test，形參為 Person 類型(形參是父類)
	//功能：調用學生的study或教師的teach方法
	 public void test(Person p) {
        if (p instanceof Student){
            ((Student) p).study();   //向下轉型
        }
        else if (p instanceof Teacher){
            ((Teacher) p).teach();  //向下轉型
        }  
	 }
}
 
//父類
class Person {
	private String name;
	
	//有參構造
	public Person(String name) {
		this.name = name;
	}
	
	// getter 和 setter
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

//子類
class Student extends Person {

	public Student(String name) {
		super(name);
	}

	// study() 方法
	public void study() {	
		System.out.println(super.getName() + "\t" + "正在好好學習");
	}
}

class Teacher extends Person {

	public Teacher(String name) {
		super(name);
	}

	// teach() 方法
	public void teach() {	
		System.out.println(super.getName() + "\t" + "正在好好教書");
	}
}

運作結果：

小藍同學	正在好好學習
小綠老師	正在好好教書

四、多态的實作方式

方式一：重寫

這個内容已經在上一章節詳細講過，就不再闡述，詳細可通路：Java 重寫(Override)與重載(Overload)。

方式二：接口

1. 生活中的接口最具代表性的就是插座，例如一個三接頭的插頭都能接在三孔插座中，因為這個是每個國家都有各自規定的接口規則，有可能到國外就不行，那是因為國外自己定義的接口類型。

2. java中的接口類似于生活中的接口，就是一些方法特征的集合，但沒有方法的實作。

方式三：抽象類和抽象方法

參考部落格：

https://blog.csdn.net/z972065491/article/details/127220556

【Java】Java進階學習筆記（三）—— 面向對象（多态）一、多态的概念二、多态的轉型三、多态執行個體四、多态的實作方式

【Java】Java進階學習筆記（三）—— 面向對象（多态）

一、多态的概念

1、多态的優點

2、多态存在的三個必要條件

3、多态中的成員特點

4、重寫方法的快捷鍵

二、多态的轉型

1、向上轉型

2、向下轉型

3、代碼示例

4、轉型的異常

類型轉換異常

instanceof 比較操作符

5、動态綁定

三、多态執行個體

1、多态的使用

2、多态數組

3、多态參數

四、多态的實作方式

方式一：重寫

方式二：接口

方式三：抽象類和抽象方法

繼續閱讀

關于Gradle配置的小結

Java小案例——随機數猜測随機數猜測

nginx location中斜線的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method