深入探討多態性及其在Java中的好處

多態是面向對象軟件的基本原理之一。該術語通常表示可以具有多種形式的事物。在面向對象的方法中，多態使編寫具有后期綁定引用的程序成為可能。盡管在Java中創建多態引用很容易，但其背后的概念對整體編程產生了更深遠的影響。本文結合在優銳課學習到的知識點，探討了有關多態性及其對面向對象編程的影響的一些復雜細節。

多態參考：概述

多態引用是一個變量，可以在不同的時間點引用不同類型的對象。它通常與它所引用的類兼容。 例如，在以下情況下：

Employee employee;

 

'employee'是一個引用變量，可以引用Employee類的實例。參考變量對參考對象的限定取決於其兼容性。這似乎是唯一可靠的條件，但事實並非如此，特別是在實現多態時。規則太嚴格了，但是通過結合“具有多種形式”的思想，多態性使得靈活性更高。這意味着多態引用保證了它可以在不同的時間點引用不同類型的對象，而不是為兼容性而完全依賴。因此，如果可以在一個時間點使用引用來調用方法，則可以將其動態更改為指向另一個對象，並在下一次調用其他方法。通過提供引用變量的另一個使用維度，這可以利用靈活性。

當引用變量綁定到無法在運行時更改的對象時，或者換句話說，方法調用與方法定義的綁定是在編譯時完成的，稱為靜態綁定。如果綁定在運行時是可更改的，例如在多態引用的情況下，綁定的決策僅在執行期間做出，則稱為動態綁定或后期綁定。兩者在面向對象程序設計中都有其用途，並非一個都勝過另一個。但是，在多態引用的情況下，推遲的綁定承諾在靈活性方面使其比編譯時綁定更具優勢，但另一方面，這會降低性能開銷。但是，這在很大程度上是可以接受的，並且在提高效率方面，開銷通常具有很小的吸引力。.

創建多態

在Java中，可以通過兩種方式創建多態引用：使用繼承或使用接口。

繼承多態

引用變量引用類的實例。對於繼承層次結構，如果引用變量在層次結構樹中聲明為父類類型，則引用對象可以指向層次結構中任何類的實例。這意味着，在Java中，因為Objectclass是所有類的父類或超類，或者換句話說，Java中的所有類實際上是Object類的子類隱式或顯式地是對象類的引用變量。對象類型可以引用Java中的任何類實例。這就是我們的意思。

Employee employee;
Object object;
employee = new Employee();
object = employee;   // This is a valid assignment

 

如果情況相反，則如下所示：

Employee employee;
Object object = new Object();
employee = (Employee)object   // Valid, but needs explicit cast

 

觀察到它需要顯式強制轉換；只有這樣，它才能成為有效的聲明。可以看出，這種反向分配對於在許多情況下出現問題的邊緣來說沒有多大用處。這是因為Object實例的功能與Employee引用變量預期的功能幾乎沒有關系。關系is-a可以從employee-is-an-object派生派生；在這種情況下，相反的關系（例如，對象是雇員）太牽強。

繼承多態性：一個例子

讓我們嘗試借助示例來理解它。

 

 圖1：從驅動程序類，公司派生的類

稱為Company的驅動程序類創建一個雇員列表，並調用paySalary()方法。薪資類維護公司中不同類型員工的列表。請注意，該數組被聲明為派生自Employee類（所有雇員子類的父級或超類）的引用變量的數組。結果，可以用從Employee類的任何子類（例如CommissionEmployee, HourlyEmployee, SalariedEmployee）創建的對象引用填充數組。在paySalary()定義中，根據數組中的對象引用調用適當的salary()方法。因此，對salary()方法的調用是多態的，很明顯，每個類都有其自己版本的salary()方法。

Payroll類中的employee數組不代表特定類型的Employee。它用作可以指向任何類型的Employee子類引用的句柄。盡管繼承的類共享作為后代繼承的一些公共數據，但是它們具有各自的屬性集。

通過繼承實現多態：Java實現

這是該示例在Java中的快速實現。

package org.mano.example;
public class Company
{
   public static void main( String[] args )
   {
      Payroll payroll = new Payroll();
      payroll.paySalary();
   }
}
package org.mano.example;
import java.util.ArrayList;
import java.util.List;
public class Payroll {
   private List<Employee> employees =
      new ArrayList<>();
   public Payroll() {
      employees.add(new
            SalariedEmployee("Harry Potter",
         "123-234-345",7800));
      employees.add(new
            CommissionEmployee("Peter Parker",
         "234-345-456",2345.67,0.15));
      employees.add(new
            HourlyEmployee("Joker Poker",
         "456-567-678",562.36,239.88));
   }
   public void paySalary() {
      for (Employee e: employees) {
         System.out.println
            ("----------------------------------------------------");
         System.out.println(e.toString());
         System.out.printf
            ("Gross payment: $%,.2f\n",e.salary());
         System.out.println
            ("----------------------------------------------------");
      }
   }
}
 
package org.mano.example;
 
public abstract class Employee {
   protected String name;
   protected String ssn;
   public Employee(String name, String ssn) {
      this.name = name;
      this.ssn = ssn;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getSsn() {
      return ssn;
   }
   public void setSsn(String ssn) {
      this.ssn = ssn;
   }
   @Override
   public String toString() {
      return String.format("%s\nSSN: %s",
         getName(),getSsn());
   }
   public abstract double salary();
}
 
package org.mano.example;
public class SalariedEmployee extends Employee {
   protected double basicSalary;
   public SalariedEmployee(String name, String ssn,
         double basicSalary) {
      super(name, ssn);
      setBasicSalary(basicSalary);
   }
   public double getBasicSalary() {
      return basicSalary;
   }
   public void setBasicSalary(double basicSalary) {
      if(basicSalary>= 0.0)
         this.basicSalary = basicSalary;
      else
         throw new IllegalArgumentException("basic " +
            "salary must be greater than 0.0");
   }
   @Override
   public double salary() {
      eturn getBasicSalary();
   }
   @Override
   public String toString() {
      return String.format("%s\nBasic Salary: $%,.2f",
         super.toString(),getBasicSalary());
   }
}
 
package org.mano.example;
public class HourlyEmployee extends Employee {
   protected double wage;
   protected double hours;
   public HourlyEmployee(String name, String ssn,
   double wage, double hours) {
      super (name, ssn);
      setWage(wage);
      setHours(hours);
   }
   public double getWage() {
      return wage;
   }
   public void setWage(double wage) {
      if(wage >= 0.0)
         this.wage = wage;
      else
         throw new IllegalArgumentException("wage " +
            "must be > 0.0");
   }
   public double getHours() {
      return hours;
   }
   public void setHours(double hours) {
      if(hours >= 0.0)
         this.hours = hours;
      else
         throw new IllegalArgumentException("hours "  +
            "must be > 0.0");
   }
   @Override
   public double salary() {
      return getHours() * getWage();
   }
   @Override
   public String toString() {
      return String.format("%s\nWage: $%,
         .2f\nHours worked: %,.2f",
         super.toString(),getWage(),getHours());
   }
}
 
package org.mano.example;
public class CommissionEmployee extends Employee {
   protected double sales;
   protected double commission;
   public CommissionEmployee(String name, String ssn,
         double sales, double commission) {
      super(name, ssn);
      setSales(sales);
      setCommission(commission);
   }
   public double getSales() {
      return sales;
   }
   public void setSales(double sales) {
      if(sales >=0.0)
         this.sales = sales;
      else
         throw new IllegalArgumentException("Sales " +
            "must be >= 0.0");
   }
   public double getCommission() {
      return commission;
   }
   public void setCommission(double commission) {
      if(commission > 0.0 && commission < 1.0)
         this.commission = commission;
      else
         throw new IllegalArgumentException("Commission " +
            "must be between 0.0 and 1.0");
   }
   @Override
   public double salary() {
      return getCommission() * getSales();
   }
   @Override
   public String toString() {
      return String.format("%s\nSales: %,
         .2f\nCommission: %,.2f",
         super.toString(),getSales(),getCommission());
   }
}

 

接口多態

接口的多態性與前面的示例非常相似，不同之處在於，這里的多態性規則是根據Java接口指定的規范進行的。接口名稱可以用作引用變量，就像我們對上面的類名稱所做的那樣。它引用實現該接口的任何類的任何對象。這是一個例子。

package org.mano.example;
public interface Player {
   public enum STATUS{PLAY,PAUSE,STOP};
   public void play();
   public void stop();
   public void pause();
}
 
package org.mano.example;
public class VideoPlayer implements Player {
   private STATUS currentStatus = STATUS.STOP;
   @Override
   public void play() {
      if(currentStatus == STATUS.STOP ||
            currentStatus == STATUS.PAUSE) {
         currentStatus = STATUS.PLAY;
         System.out.println("Playing Video...");
      }
      else
         System.out.println("I am ON playing man!");
   }
   @Override
   public voidstop() {
      if(currentStatus == STATUS.PLAY ||
            currentStatus == STATUS.PAUSE) {
         currentStatus = STATUS.STOP;
         System.out.println("Video play stopped.");
      }
      else
         System.out.println("Do you want me to go fishing?");
   }
   @Override
   public void pause() {
      if(currentStatus == STATUS.PLAY) {
         currentStatus = STATUS.PAUSE;
         System.out.println("Video play paused.");
      }
      else
         System.out.println("I'm a statue. You froze me
            already!");
      }
   }
 
package org.mano.example;
public class AudioPlayer implements Player {
   private STATUS currentStatus = STATUS.STOP;
   @Override
   public void play() {
      if(currentStatus == STATUS.STOP ||
            currentStatus == STATUS.PAUSE) {
         currentStatus = STATUS.PLAY;
         System.out.println("Playing Audio...");
      }
      else
         System.out.println("I am ON playing man!");
   }
   @Override
   public void stop() {
      if(currentStatus == STATUS.PLAY ||
            currentStatus == STATUS.PAUSE) {
         currentStatus = STATUS.STOP;
         System.out.println("Audio play stopped.");
      }
      else
         System.out.println("Do you want me to go fishing?");
   }
   @Override
   public void pause() {
      if(currentStatus == STATUS.PLAY) {
         currentStatus = STATUS.PAUSE;
         System.out.println("Audio play paused.");
      }
      else
         System.out.println("I'm a statue. You froze me
            already!");
      }
   }
 
package org.mano.example;
public class PlayerApp {
   public static void main(String[] args) {
      Player player= new VideoPlayer();
      player.play();
      player.pause();
      player.stop();
      player= new AudioPlayer();
      player.play();
      player.pause();
      player.stop();
   }
}

 

請注意，在PlayerApp中，我們已經使用接口Player來聲明對象引用變量。引用變量player可以引用實現Player接口的任何類的任何對象。為了證明這一點，我們在這里使用了同一播放器變量來引用VideoPlayer對象和AudioPlayer對象。運行時調用的方法是特定於其引用的類對象的方法。實現接口的類與接口本身之間的關系是父子關系，正如我們在帶有繼承的多態示例中所看到的。它也是一個is-arelationship，並構成了多態性的基礎。

總結

通過類繼承或通過接口實現多態性之間的差異是一個選擇問題。實際上，區別在於理解類和接口的屬性和特性。除了了解其性質外，沒有嚴格的規則來定義何時使用。這超出了本文的范圍。但是，在多態中，這個想法既適合並且也有能力完成我們想對它們進行的操作。就這樣。抽絲剝繭，細說架構那些事——【優銳課】