Java的多态

一、什么是多态
多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。

如果将对象的方法视为对象向外界提供的服务，那么运行时的多态性可以解释为：当A系统访问B系统提供的服务时，B系统有多种提供服务的方式，但一切对A系统来说都是透明的（就像电动剃须刀是A系统，它的供电系统是B系统，B系统可以使用电池供电或者用交流电，甚至还有可能是太阳能，A系统只会通过B类对象调用供电的方法，但并不知道供电系统的底层实现是什么，究竟通过何种方式获得了动力）。

方法重载（overload）实现的是编译时的多态性（也称为前绑定），而方法重写（override）实现的是运行时的多态性（也称为后绑定）。

二、Java多态
多态是同一个行为具有多个不同表现形式或形态的能力。
多态就是同一个接口，使用不同的实例而执行不同操作，如图所示：

多态性是对象多种表现形式的体现。

三、多态的优点

1. 消除类型之间的耦合关系
2. 可替换性
3. 可扩充性
4. 接口性
5. 灵活性
6. 简化性

四、多态存在的三个必要条件

1. 继承
2. 重写
3. 父类引用指向子类对象：Parent p = new Child();

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

多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

以下是一个多态实例的演示，详细说明请看注释：

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

执行以上程序，输出结果为：

吃鱼
抓老鼠
吃骨头
看家
吃鱼
抓老鼠

五、多态的实现方式

方式一：重写

方式二：接口

1. 生活中的接口最具代表性的就是插座，例如一个三接头的插头都能接在三孔插座中，因为这个是每个国家都有各自规定的接口规则，有可能到国外就不行，那是因为国外自己定义的接口类型。

2. java中的接口类似于生活中的接口，就是一些方法特征的集合，但没有方法的实现。具体可以看 java接口 这一章节的内容。

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

六、多态中成员的特点
1、多态成员变量：编译运行看左边
Fu f=new Zi();

     System.out.println(f.num);//f是Fu中的值，只能取到父中的值

2、多态成员方法：编译看左边，运行看右边

    Fu f1=new Zi();

    System.out.println(f1.show());//f1的门面类型是Fu,但实际类型是Zi,所以调用的是重写后的方法。

七、instanceof关键字
作用：用来判断某个对象是否属于某种数据类型。

注意： 返回类型为布尔类型
使用案例：

   Fu f1=new Zi();
  Fu f2=new Son();
if(f1 instanceof Zi){
    System.out.println("f1是Zi的类型");
}
else{
    System.out.println("f1是Son的类型");
}

//测试类
class DuoTaiDemo02{
    public static void main(String[] args){
        Dog d=new Dog();
        Cat c=new Cat();
        Pig p=new Pig();
        feed(d);//调用函数
        feed(c);
        feed(p);
    }
    //Animal a=new Dog();
    //Animal a=new Cat(); 向上类型转换
    public static void feed(Animal a){
        a.eat();
        a.jiao();
        //ClassCastException 类型转换异常
        //判断对象的本质类型 instanceOf
        //在这里只有猪才拱白菜，其他动物不会
        if(a instanceof Pig){
            Pig pp=(Pig)a;
            pp.gongBaiCai();
        }
         if(a instanceof Dog){
            Dog dd=(Dog)a;
            dd.lookDoor();
        }
        if(a instanceof Cat){
            Cat cc=(Cat)a;
            cc.catchMouse();
        }
    }
}
/*
运行结果
狗吃狗粮......
狗汪汪汪......
狗看家~......
猫吃鱼......
猫喵喵喵......
猫捉老鼠~......
猪啥都吃......
猪哼哼哼......
猪拱白菜......
*/
 
 class Animal{
     void eat(){
 
    }
     void jiao(){
 
    }
}
//子类
class Pig extends Animal{
    //重写
    void eat(){
        System.out.println("猪啥都吃......");
    }
    void jiao(){
        System.out.println("猪哼哼哼......");
    }
    //特有属性
    void gongBaiCai(){
        System.out.println("猪拱白菜......");
    }
}
//子类
class Dog extends Animal{
    //重写
    void eat(){
        System.out.println("狗吃狗粮......");
    }
    void jiao(){
        System.out.println("狗汪汪汪......");
    }
    //特有属性
    void lookDoor(){
        System.out.println("狗看家~......");
    }
}
//子类
class Cat extends Animal{
    //重写
    void eat(){
        System.out.println("猫吃鱼......");
    }
    void jiao(){
        System.out.println("猫喵喵喵......");
    }
    //特有属性
    void catchMouse(){
        System.out.println("猫捉老鼠~......");
    }
}

八、多态的转型
多态的转型分为向上转型和向下转型两种
向上转型：多态本身就是向上转型过的过程
使用格式：父类类型 变量名=new 子类类型();

适用场景：当不需要面对子类类型时，通过提高扩展性，或者使用父类的功能就能完成相应的操作。

向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用类型转为子类引用各类型
使用格式：子类类型 变量名=（子类类型） 父类类型的变量；
适用场景：当要使用子类特有功能时。

九、多态的优缺点
优点：

1. 可替换性(substitutability)。多态对已存在代码具有可替换性。例如，多态 对圆 Circle类工作，对其他任何圆形几何体，如圆环，也同样工作。
2. 可扩充性(extensibility)。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如，在实现了圆锥、半圆锥以及半球体的多态基础上，很容易增添球体类的多态性。
3. 接口性(interface-ability)。多态是超类通过方法签名，向子类提供了一个共 同接口，由子类来完善或者覆盖它而实现的。
4. 灵活性(flexibility)。它在应用中体现了灵活多样的操作，提高了使用效率。
5. 简化性(simplicity)。多态简化对应用软件的代码编写和修改过程，尤其在处 理大量对象的运算和操作时，这个特点尤为突出和重要。

缺点：多态不能访问子类特有的功能