以下內容引用自http://wiki.jikexueyuan.com/project/java/polymorphism.html：

多態性是指對象能夠有多種形態。在OOP中最常用的多態性發生在當父類引用指向孩子類對象時。

任何能夠通過一個以上的IS-A測試的Java對象被認為是多態的。在Java中所有對象都是多態的，因為任何一個對象都會有一個他們自己類型的和Object類的IS-A關系。

重要的是知道，通過引用變量是唯一可以用來訪問一個對象的方法。引用變量可以只有一個類型。引用變量一旦被聲明是不能被改變的。

引用變量能夠重新分配到其他提供的沒有被聲明為final的對象。引用變量的類型將決定它可以調用的對象的方法。

一個引用變量能夠引用任何一個對象的聲明類型或任何聲明類型的子類型。一個引用變量可以聲明為一個類或接口類型。

示例：

看下面的例子：

public interface Vegetarian{}
public class Animal{}
public class Deer extends Animal implements Vegetarian{}

現在Deer類是多態的，因為他有多個繼承機制。針對上面的例子有以下說法：

• Deer就是Animal
• Deer就是Vegetarian
• Deer就是Deer
• Deer就是Object

當提供引用變量來引用Deer對象，下面的聲明是合法的：

Deer d = new Deer();
Animal a = d;
Vegetarian v = d;
Object o = d;

所有的引用變量d，a，v，o在堆中引用同一個對象Deer。

一、虛方法

這裏將展示在Java中被覆蓋方法的行為在設計類時是如何體現多態性的好處。

一個子類可以覆蓋它父類的方法。一個被覆蓋的方法實際上隱藏在父類當中，並且不會被調用，除非子類在覆蓋方法中用super關鍵字。

/* File name : 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("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }
   public void mailCheck()
   {
      System.out.println("Mailing a check to " + 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類：

/* File name : Salary.java */
public class Salary extends Employee
{
   private double salary; //Annual salary
   public Salary(String name, String address, int number, double salary)
   {
       super(name, address, number);
       setSalary(salary);
   }
   public void mailCheck()
   {
       System.out.println("Within mailCheck of Salary class ");
       System.out.println("Mailing check to " + getName() + " with salary " + salary);
   }
   public double getSalary()
   {
       return salary;
   }
   public void setSalary(double newSalary)
   {
       if(newSalary >= 0.0)
       {
          salary = newSalary;
       }
   }
   public double computePay()
   {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
}

現在，仔細研究下面的程序，試圖確定它的輸出:

/* File name : VirtualDemo.java */
public class VirtualDemo
{
   public static void main(String [] args)
   {
      Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
      Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
      System.out.println("Call mailCheck using Salary reference --");
      s.mailCheck();
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
    }
}
//這將產生如下的結果:
Constructing an Employee
Constructing an Employee
Call mailCheck using Salary reference --
Within mailCheck of Salary class
Mailing check to Mohd Mohtashim with salary 3600.0

Call mailCheck using Employee reference--
Within mailCheck of Salary class
Mailing check to John Adams with salary 2400.0

這裏實例化兩個Salary對象。一個用Salary引用s，另一個用Employee引用e。

當調用s.mailCheck()方法時，編譯器在編譯時發現mailCheck()在Salary類中，並且JVM在運行時調用Salary類的mailCheck()方法。

調用e的mailCheck()是略有不同的因為e是一個Employee的引用。當編譯器發現e.mailCheck()時，編譯器在Employee類中發現mail.Check()方法。

這裏在編譯時，編譯器使用Employee的mailCheck()方法來驗證。在運行時，JVM調用Salary類的mailCheck()類。

這種行為被稱為虛方法調用，該方法也被稱為虛方法。Java中所有此規則的方法行為，無論是什麽數據類型的引用，運行時會調用被覆蓋方法，在編譯時都會遵循於源碼。

測試工程：https://github.com/easonjim/5_java_example/tree/master/javabasicstest/test19

Java中的多態