2021-1-10 多态

多态语法机制

关于java语言当中的多态语法机制：

1. Animal、Cat、Bird三个类之间的关系：
   Cat继承Animal
   Bird继承Animal
   Cat和Bird之间没有任何继承关系
2. 面向对象三大特征：封装、继承、多态
3. 关于多态中涉及到的几个概念：
   （1）向上转型（upcasting）
   子类型–>父类型
   又被称为：自动类型转换。*
   （2）向下转型（downcasting）
   父类型-—>子类型
   又被称为：强制类型转换。【需要加强制类型转换符】
   （3）需要记忆：
   无论是向上转型还是向下转型，两种类型之间必须要有继承关系。
   没有继承关系，程序是无法编译通过的。

public class Test{
public static void main(string[] args){
Animal al=new Animal();
 al. move();
 
 Cat cl=new Cat(); 
 c1. move(); 
 c1. catchMouse(); 
 
 Bird b1=new Bird(); 
 b1. move();
}
}

1. Animal和Cat之间存在继承关系，Animal是父类，Cat是子类
2. Cat is a Animal
3. new Cat（）创建的对象的类型是cat，a2这个引用的数据类型是Anima1，可见它们进行了类型转换，子类型转换成父类型，称为向上转型/upcasting，或者称为自动类型转
4. Java中允许这种语法：父类型引用指向子类型对象。

 Animal a2=new Cat（）

*1、java程序永远都分为编译阶段和运行阶段。
*2、先分析编译阶段，再分析运行阶段，编译无法通过，根本是无法运行的。
*3、编译阶段编译器检查a2这个引用的数据类型为Animal，由于Animal.class
*字节码当中有move（）方法，所以编译通过了。这个过程我们成为静态绑定，编译阶段绑定。
*只有静态绑定成功之后才有后续的运行。
*4、在程序运行阶段，Jvni内存当中真实创建的对象是Cat对象，那么以下程序在运行阶段
*一定会调用Cat对象的move（）方法，此时发生了程序的动态绑定，运行阶段绑定。
a2.move（）；//猫在走猫步！
*5、无论是Cat类有没有重写move方法，运行阶段一定调用的是Cat对象的move方法，因为底层
*真实对象就是Cat对象。
*6、父类型引用指向子类型对象这种机制导致程序存在编译阶段绑定和运行阶段绑定两种不同的形态/状态，这种机制可以成为一种多态语法机制。

1、以下程序编译是没有问题的，因为编译器检查到a3的数据类型是Animal Animal和cat之间存在继承关系，并且Anima1是父类型，cat是子类型，父类型转换成子类型叫做向下转型，语法合格。
2、程序虽然编译通过了，但是程序在运行阶段会出现异常，因为JV维内存当中真实存在的对象是Bird类型，Bird对象无法转换成Cat对象，因为两种类型之间不存在任何继承关系，此时出现了著名的异常：
java.lang.ClassCastException类型转换异常，这种异常总是在“向下转型”的时候会发生。

1、以上异常只有在强制类型转换的时候会发生，也就是说“向下转型存在隐患（编译过了，但是运行错了！）
2、向上转型只要编译通过，运行一定不会出问题：Animala=new Cat（）
3、向下转型编译通过，运行可能错误：Animal as=new Bird（）：Cat c3=（Cat）a3；
4、怎么避免向下转型出现的ClasscastException呢？
使用instanceof运算符可以避免出现以上的异常。
5.instanceo运算符怎么用？
5.1、否法格式：L
（引用instanceof 数据类型名）
5.2、以上运算符的执行结果类型是布尔类型，结果可能是true/false
5.3、关于运算结果true/false：假设：（a instanceof Animal）
true表示：
a这个引用指向的对象是一个Anima1类型。
false表示：
a这个引用指向的对象不是一个Anima1类型。
6、Java规范中要求：在进行强制类型转换之前，建议采用instanceof运算符进行判断，避免C1asscastException异常的发生。这是一种编程好习惯。

多态在实际开发中的作用

多态在实际开发中的作用，以下以主人喂养宠物为例说明多态的作用：

1. 分析：主人喂养宠物这个场景要实现需要进行类型的抽象：
   主人【类】
   王人可以喂养宠物，所以主人有喂养的这个动作
   宠物【类】
   宠物可以吃东西，所以宠物有吃东西的这个动作
2. 面向对象编程的核心：定义好类，然后将类实例化为对象，给一个环境驱使一下，让各个对象之间协作起来形成一个系统。
3. 多态的作用是什么？
   降低程序的耦合度，提高程序的扩展力。
   能使用多态尽量使用多态。父类型引用指向子类型对象。
   核心：面向抽象编程，尽量不要面向具体编程。

例子

未使用继承和多态`
存在的缺点：Hoster的扩展力很差，因为只要加一个新的宠物，Hoster类就需要添加新的方法。

public class Test {
    public static void main(String[] args) {
        Hoster zhangsan= new Hoster();//创建对象
        Cat tom= new Cat();
        zhangsan.feed(tom);//主人喂养猫
        Dog lasi= new Dog();
        zhangsan.feed(lasi);//主人喂狗
    }
}
public class Hoster {
    //喂养宠物的方法
    public void feed(Cat c) {
        c.eat();
    }
    public void feed(Dog d) {
        d.eat ();
    }
}
public class Cat {
    public void eat(){
        System.out.println("猫在吃鱼");
    }
}
public class Dog {
    public void eat(){
        System.out.println("狗在吃骨头");
    }
}

使用了继承和多态

public class Test {
    public static void main(String[] args) {
        Hoster zhangsan= new Hoster();//创建对象
        Cat tom= new Cat();
        zhangsan.feed(tom);//主人喂养猫
        Dog lasi= new Dog();
        zhangsan.feed(lasi);//主人喂狗
        zhangsan.feed(new Snake());
    }
}
public class Hoster {
    //喂养宠物的方法
    //Hoster主人类面向的是一个抽象的Pet，不再面向具体的宠物,提倡面向抽象编程，而不是面向具体编程
    public void feed(Pet pet){//Pet pet是一个父类型的引用
        pet.eat();
    }
}
public class Pet {//父类宠物
    public void eat(){
    }
}
//猫喜欢吃鱼

public class Cat extends Pet {
    public void eat(){
        System.out.println("猫在吃鱼");
    }
}
//狗喜欢吃骨头
public class Dog extends Pet{
    public void eat(){
        System.out.println("狗在吃骨头");
    }
}
public class Snake extends Pet {
    public void eat(){
        System.out.println("蛇吞象");
    }
}