Java多态性
多态是对象采取多种形式的能力。当使用父类引用子类对象时，会在OOP中最常见地使用多态。
任何可以通过多个IS-A测试的Java对象都被视为多态的。在Java中，所有Java对象都是多态的，因为任何对象都将通过IS-A测试，以了解其自身的类型以及Object类。
重要的是要知道访问对象的唯一可能方法是通过引用变量，引用变量只能是一种类型。声明后，引用变量的类型将无法更改。
如果未将引用变量声明为final，则可以将其重新分配给其他对象。引用变量的类型将确定它可以在对象上调用的方法。
引用变量可以引用其声明类型的任何对象或其声明类型的任何子类型。引用变量可以声明为类或接口类型。
让我们来看一个例子。
public interface Vegetarian{}
public class Animal{}
public class Deer extends Animal implements Vegetarian{}现在，Deer类被认为是多态的，因为它具有多重继承。以上示例说明：
Deer IS-A Animal
Deer IS-A Vegetarian
Deer IS-A Deer
Deer IS-A 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; //年薪
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() ，则编译器会在编译时在Salary类中看到mailCheck()，而JVM在运行时会在Salary类中调用mailCheck()。
mailCheck()在e是完全不同的，因为e是Employee引用。当编译器看到 e.mailCheck() ，编译器会在Employee类中看到mailCheck()方法。
在编译时，编译器使用Employee中的mailCheck()来验证此语句。但是，在运行时，JVM会在Salary类中调用mailCheck()。
此行为称为虚拟方法调用，而这些方法称为虚拟方法。无论在编译时在源代码中使用的引用是哪种数据类型，都将在运行时调用重写的方法。