面向对象编程的三大特性（多态）

基本含义

基本点

语法： 父类名 对象名 = new 子类名();

项目	含义
含义	同一个接口，使用不同的实例，进而执行不同的操作
优点	灵活、简化、接口性，可替换、扩充性，消除类型间的耦合关系
必要条件	继承、重写、父类引用指向子类对象。

多态使用——系统调用步骤

Animal cat = new Cat();
cat.eat();
当使用多态方式调用方法时：

1. 检查父类是否有该方法。无则出错。

2. 父类有该方法时，去调用子类同名方法。
   这个过程也叫虚拟方法。
   Cat cat = new Cat();
   cat.eat();
   当不使用多态方式调用方法时：

3. 不会查看父类。

4. 直接调用子类方法。

父类引用指向子类对象

含义

1. 对象名。objectName。
2. 对象类型。父类名。
3. 选用的构造函数。子类构造器。

ParentClassName objectName = new ChildClassName();

多态的实现方式

方式一：重写
方式二 :接口
方式三:抽象类和抽象方法。

实参

实参类型	示例
基本数据类型	cat.eat(“苹果”);
引用数据类型	num.findMax(arr1);
实例对象	eat(new Cat());

强制转换——父子间

原则：

1. 直接转换：子转父。
2. 强制转换：父转子。

// =====================各自对应类定义对象===================
// 情况1：子可直接转父。
Animal animal = new Animal();
Cat cat = new Cat();
animal = cat; // 结果：正确
// 情况2：子可直接转父，但不能同时重复转。
Animal animal = new Animal(); // 创建实例对象animal
Cat cat = new Cat(); // 创建实例对象cat
Dog dog = new Dog(); // 创建实例对象dog
animal = cat; // 结果：正确。子可直接转父
animal = dog; // 结果：错误。但不能同时重复转
// 情况3：父可强制转子。
Animal animal = new Animal(); // 创建实例对象animal
Cat cat = new Cat(); // 创建实例对象cat
cat = (Cat)animal; // 结果：正确。父可强制转子。
// =====================多态定义对象===================
// 情况1：子可直接转父。
Animal animal = new Animal();
Animal cat = new Cat(); // 
animal = cat; // 结果：正确。
// 情况2：子可直接转父，但不能同时重复转。
Animal animal = new Animal();
Animal cat = new Cat();
animal = cat; // 结果：正确。
animal = dog; // 结果：出错。
// 情况3：父可强制转子。
Animal animal = new Animal();
Animal cat = new Cat();
Cat cat = new Cat();
cat = (Cat)animal; // 正确。父可强制转子。 
// =====================各自对应类定义对象和多态定义对象===================
// 情况1： 。
Animal cat1 = new Cat();
Cat cat2 = new Cat();
cat2 = cat1;  //  出错 
cat1 = cat2; // 正确
// 情况2： 。
Animal cat1 = new Cat();
Cat cat2 = new Cat();
cat2 = (Cat)cat1;  // 正确 
cat1 = cat2; // 正确

具体操作

动物：猫、狗。
主函数入口类：

public class MainEntrance{
  public static void main(String[] args){
    /*  类方法调用：实例对象作为实参。
     * 等价于：
     * Cat a = new Cat();
     * show(a);
     * 或者
     * Animal b = new Cat(); // 多态方式。
     */
    show(new Cat()); 
    show(new Dog());
    
    Animal a = new Cat();
    a.eat();
    Cat c = (Cat)a;
    c.work();
  }
  public static void show(Animal a){ // 多态方式。父类引用，指向子类。
    a.eat(); // 多态方式调用方法：先看父有无后调子方法。
    if(a instanceof Cat){ // 判断实例对象的类型。此时只知道a是动物。
       Cat c = (Cat)a; // 强制转换
       c.work();
     }else if(a instanceof Dog){
       Dog c = (Dog)a;
       c.work();
     }     
    }
  }  
}

动物类：

public class Animal{
  public void eat(){
    System.out.println("都需要食物补充营养！");
  }
}

猫类：

public class Cat extends Animal{
  public void eat(){
    System.out.println("喜欢吃鱼");
  }
  public void work(){
    System.out.println("任务是抓老鼠！");
  }
}

狗类：

public Dog extends Animal{
  public void eat(){
    System.out.println("喜欢吃骨头！");
  }
  public void work(){
    System.out.println("任务是看家护院！");
  }
}