JAVA类与对象（九）------多态

多态是同一个行为具有多个不同表现形式或形态的能力。多态性是对象多种表现形式的体现。

多态存在的三个必要条件:

• 继承
• 重写
• 父类引用指向子类对象

例：Parent p = new Child();

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

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("看家");
    }
} 

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 的 catchMouse
  }              

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();
        }
    }  

}
 

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAQIAAABzCAIAAAD8JJvXAAAEy0lEQVR4nO3dQXLkLAyGYe48p/lvk0tkmVU22c4NZjFVLhcSQhgB1vzvs0jFbux0T/E1wj1uys/Pz/f399fX1+fn5+//fpVpHx8f18/7nnSqp73tVfwD/3T5rIvBZf6c6l9RrfsrsWd+2x/9vwuPAZAPMQC8MXAO0IzjSIkYAEoM5BTNn4HVc1ZgCTUGfx+6/9Lt4mqPJwbIoRsDT1cmA8jNjoEzA10LXwAw71lRdB2ujhieegl4EU8MKnI/MUBuozFo7aQoQmL+GBgdmtEAuXk+Nyi9rkwMkJtzimyfhKIIuXX/M4V/ogxkRQwA13+tM0qdbjlEaYQEuN8AIAYAMQBKOwZGKT/0GYKNCQNeYTQG3fmufEjdI0/CZBrHeGLQveBjX0pS2xtPiRhgN2cMqp8GeaDaRoaK0QDHVDEw3tFHYzBUOPkfBeJNjgatcqhVI8mTS8QAu4UXRZ42/sAAO9gxmCmKgDSMGFRVfjcG6hu52r46lboJ7KPGQC3l7W4qDzHKGzsAxAC7qVeKSntuULRuejVwFvdVA3sTWG50ilzavbb73m+fkKIIxzyIQWl02dEYyDPfNwkD9unGwN/jH8TA2CQG2Kd1S74dA7l57VTJZvLMVcyIAfZpXSmqfolV9XIjKsAO3HYDEAMgbtGn1qzAWdtQAuGkwBg8O3CoGbBE1NpnrUHAOLaaJT98AcC8RWufOSO0+pIU4BKy9plsZvdvNWkDTxqItWftM//oARwwufZZmR4uhk4CLDG59pkRlXtmur2cGOCkkLXP/Pv9FRTBwD4ha5+V3mhgo8fjsJC1z4wG/hgQBhwTsvZZmRgNhsIGLBG16NOz0UA+ShJwwMEYzNRRQKTJtc/ubeRR6v7Sm223jgJWibrfoNXd5R6uHeF1uO0GIAbAyG03zmug1DPIx/74zHntv0ISkIzzSpFxhtZ1pMksAfsY32jt7NDO/k0M8F6PPz7zPDraDDijuwRgd0ygIkJ69mjwoPvS45GPEYPRDn296z+bPADH2Gufecobub8qmRa/AmCa8Y3Wag/uduv7sWQAOXS/oMU/2a0GATKANOSVoush52hgFEUkATnYU+Sh0aBoAWBYQAKjV4pafVoOCMajwLtMjgZqRVQoh5BL1Ggw2gZ4EW67AYgBELfo01Az4F2IARC29llpXFla9byBQIvWPjN2Aq8TsvYZGUBue9Y+W/gCgHmTa5+pI4anXgJeZHLtM3UPMUAyIWufURQht5C1zxgNkFvI2mfEALmFrH1GUYTcohZ9AhIjBsDs2mfdcojSCAlwvwFADABiABTzO0xbhwx9hmBjwoBXGI1Bd74rH1L3yJMwmcYxnhh0L/jYl5LU9sZTIgbYzRmD6qdBHqi2kaFiNMAx3UWfytMYDBVO/keBeJOjQascatVI8uQSMcBu4UWRp40/MMAOdgxmiiIgDXvts+v34oiB+kautq9OpW4C+7TWPmsVRaXds6tDjPLGDgAxwG7qlaLSnhsUrZteDZzFfdXA3gSWG50il3av7b732yekKMIxD2JQGl12NAbyzPdNwoB9ujHw9/gHMTA2iQH2ad2Sb8dAbl47VbKZPHMVM2KAfVpXiqpfYlW93IgKsAO33QDEACAGQCEGQCEGQCl/AJpW6e8AZ2+WAAAAAElFTkSuQmCC" alt="" />

虚方法：

在Java中，当设计类时，被重写的方法的行为怎样影响多态性。方法的重写，也就是子类能够重写父类的方法。

当子类对象调用重写的方法时，调用的是子类的方法，而不是父类中被重写的方法。要想调用父类中被重写的方法，则必须使用关键字super。

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;
   }
}

class Salary extends Employee
{
   private double salary; // 全年工资
   public Salary(String name, String address, int number, double salary) {
       super(name, address, number);
       setSalary(salary);
       System.out.println("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;
   }
}

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();
    }
}

aaarticlea/png;base64,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" alt="" />

例子解析

• 实例中，实例化了两个 Salary 对象：一个使用 Salary 引用 s，另一个使用 Employee 引用 e。

• 当调用 s.mailCheck() 时，编译器在编译时发现 mailCheck() 在 Salary 类中，执行过程就调用 Salary 类的 mailCheck()。

• 因为 e 是 Employee 的引用，所以调用 e 的 mailCheck() 方法时，编译器会去 Employee 类查找 mailCheck() 方法 。

• 在编译的时候，编译器使用 Employee 类中的 mailCheck() 方法验证该语句， 但是在运行的时候，调用的是 Salary 类中的mailCheck()方法。

以上整个过程被称为虚拟方法调用，该方法被称为虚拟方法。

Java中所有的方法都能以这种方式表现，因此，重写的方法能在运行时调用，不管编译的时候源代码中引用变量是什么数据类型。