多态理解

当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则编译错误;如果有,再去调用子类的同名方法

多态必要条件

1. 继承
2. 重写
3. 父类引用指向子类对象

---

多态简单例子

package basicForMando；
/*
 * @name 多态
 * @description 公共父类
 * @question 
 *  1.Cat 是什么 和  Animal2 有关吗
 *  2. instanceof 如何判断类型
 *  3. (Cat)a 是什么意思 为什么带括号
 * */
public class Polymorphic {

    public static void main(String[] args) {
        show(new Cat());//3 Cat对象调用show方法
    }
    //  3.1 传参new Cat() 到 a => Animal2 a = new Cat();
    public static void show(Animal2 a){
        //4.1 输出 new Cat().eat()
        a.eat();
        // 判断类型     
        if(a instanceof Cat){
            System.out.println(a);
            // instanceof Cat ?         
            System.out.println(a instanceof Cat);
            //(Cat)a
            Cat cat =(Cat)a;
            //4.2 输出 Cat().work()
            cat.work();
        }
    }

}
//1.建立父类(超类)
abstract class Animal2{
//  方法还是变量?
    abstract void eat();
}
//2.继承父类
class Cat extends Animal2{
    //2.1 重写父类方法(父类中没有就会报错)
    public void eat(){
        System.out.println("吃鱼");
    }
    //2.2 子类独有方法    
    public void work(){
        System.out.println("抓老鼠");
    }
    
}

---

多态复杂例子

Employee(父类超类)

package finance;
/*
 * 父类(超类)
 * 构造函数里 this.name 是成员变量private String name,name 为参数String name;
 * */
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 是成员变量private String name,name 为参数String name;
          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;
      }
}

Salary(子类继承父类)

package finance;

public class Salary extends Employee {
    private double salary;//全年工资
      //    继承父类,子类构造函数
      public Salary(String name,String address,int number,double salary){
          // 传参继承的父类Employee
          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;
      }
}

输出

package finance;

public class VirtualDemo {
    public static void main(String[] args) {
          // TODO Auto-generated method stub
          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();
      }
}

--print--
Employee 构造函数
Employee 构造函数
使用 Salary 的引用调用 mailCheck -- 
Salary 类的 mailCheck 方法
邮寄支票给:员工 A,工资为:3600.0

使用 Employee 的引用调用 mailCheck--
Salary 类的 mailCheck 方法
邮寄支票给:员工 B,工资为:2400.0

例子解析

1. 实例中，实例化了两个 Salary 对象：一个使用 Salary 引用 s，另一个使用 Employee 引用 e。
2. 当调用 s.mailCheck() 时，编译器在编译时会在 Salary 类中找到mailCheck()，执行过程 JVM 就调用 Salary 类的 mailCheck()。
3. 因为 e 是 Employee 的引用，所以调用 e 的 mailCheck() 方法时，编译器会去 Employee 类查找 mailCheck() 方法 。
4. 在编译的时候，编译器使用 Employee 类中的 mailCheck() 方法验证该语句， 但是在运行的时候，Java虚拟机(JVM)调用的是 Salary 类中的 mailCheck() 方法。

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

多态的实现方式

多态的实现方式

方式一：重写

这个内容已经在上一章节详细讲过，就不再阐述，详细可访问：Java 重写(Override)与重载(Overload)。

方式二：接口

• 1. 生活中的接口最具代表性的就是插座，例如一个三接头的插头都能接在三孔插座中，因为这个是每个国家都有各自规定的接口规则，有可能到国外就不行，那是因为国外自己定义的接口类型。
• 2. java中的接口类似于生活中的接口，就是一些方法特征的集合，但没有方法的实现。具体可以看 java接口 这一章节的内容。

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

详情请看 Java抽象类 章节。