java 多态 Polymorphic

简述

多态是指，针对某个类型的方法调用，其真正执行的方法取决于运行时期实际类型的方法。
多态的特性就是，运行期才能动态决定调用的子类方法。对某个类型调用某个方法，执行的实际方法可能是某个子类的覆写方法

多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。用白话来说，就是多个对象调用同一个方法，得到不同的结果。

多态的语法格式

父类类名 引用名称 = new 子类类名();

当是多态时，该引用名称只能访问父类中的属性和方法，但是访问的时候，会优先访问子类重写以后的方法。

多态分两种：

编译时多态（设计时多态）：方法重载。

其中编译时多态是静态的，主要是指方法的重载，它是根据参数列表的不同来区分不同的方法。通过编译之后会变成两个不同的方法，在运行时谈不上多态。

运行时多态：

JAVA运行时系统根据调用该方法的实例的类型来决定选择调用哪个方法则被称为运行时多态。（我们平时说得多的事运行时多态，所以多态主要也是指运行时多态）

多态是指父类的某个方法被子类重写时，可以产生自己的功能行为，同一个操作 作用于不同对象，可以有不同的解释，产生不同的执行结果。
多态性是面向对象编程的又一个重要特征，它是指在父类中定义的属性和方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为，这使得同一个属性或方法在父类及其各个子类中具有不同的含义。

运行时多态存在的三个必要条件：

• 一、要有继承（包括接口的实现）；
• 二、要有重写；
• 三、父类引用指向子类对象。 向上转型

什么是多态

面向对象的三大特性:封装、继承、多态。

从一定角度来看，封装和继承几乎都 是为多态而准备的。这是我们最后一个概念，也是最重要的知识点。

多态的定义:指允许不同类的对象对同一消息做出响应。即同一消息可以根据发 送对象的不同而采用多种不同的行为方式。(发送消息就是函数调用)

实现多态的技术称为:动态绑定(dynamic binding)，是指在执行期间判断所 引用对象的实际类型，根据其实际的类型调用其相应的方法。

多态的作用:消除类型之间的耦合关系。

现实中，关于多态的例子不胜枚举。比方说按下 F1 键这个动作，如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档;如果当前在 Word 下弹出的就是Word 帮助;在 Windows 下弹出的就是 Windows 帮助和支持。
同一个事件发 生在不同的对象上会产生不同的结果。

多态的好处：

1.可替换性（substitutability）。多态对已存在代码具有可替换性。例如，多态对圆Circle类工作，对其他任何圆形几何体，如圆环，也同样工作。

2.可扩充性（extensibility）。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如，在实现了圆锥、半圆锥以及半球体的多态基础上，很容易增添球体类的多态性。

3.接口性（interface-ability）。多态是超类通过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。如图8.3 所示。图中超类Shape规定了两个实现多态的接口方法，computeArea()以及computeVolume()。子类，如Circle和Sphere为了实现多态，完善或者覆盖这两个接口方法。

4.灵活性（flexibility）。它在应用中体现了灵活多样的操作，提高了使用效率。

5.简化性（simplicity）。多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。

多态中的类型转换

Java多态中，有两种类型转换：向上转型和向下转型

向上转型

向上转型，也叫做自动类型转换，子类型赋值给父类型（父类型的引用指向子类型），构成多态
父类类型 引用名称 = new 子类类名();

当使用多态方式调用方法时，该引用名称只能访问父类中的属性和方法。编译器首先检查父类中是否有该方法，如果没有，则编译错误。如果有，再去调用子类的同名（重写）方法。

向下转型

向下转型，也叫做强制类型转换，父类型赋值给子类型

当使用多态时，并且访问子类独有的属性或方法时，则必须进行向下转型

当进行向下转型时，建议先使用 instance of 关键字进行判断，判断合法时，则在转为对应的类型，否则可能会出现类型转换异常 java.lang.ClassCastException。

说明：instance of 关键字用于判断一个对象，是否属于某个指定的类或其子类的实例。

多态简单使用案例

场景：假如有个饲养员，需要给不同的宠物喂食，下面给出使用多态和不使用多态的实现方式。

不使用多态的实现：

首先定义一个抽象类Animal、一个饲养员类AnimalKeeper、一个宠物类Dog和一个宠物类Cat。

public abstract class Animal {

    public void eat() {
        System.out.println("动物吃东西！");
    }
}

/**
 * 饲养员
 */
public class AnimalKeeper {

	/**
	 * 给宠物猫喂食
	 *
	 * @param cat
	 */
	public void feed(Cat cat) {
		cat.eat();
	}

	/**
	 * 给宠物狗喂食
	 *
	 * @param dog
	 */
	public void feed(Dog dog) {
		dog.eat();
	}

}

public class Dog extends Animal {

    @Override
    public void eat() {
        System.out.println("狗啃骨头！");
    }
}
public class Cat extends Animal {

	@Override
	public void eat() {
		System.out.println("猫吃鱼！");
	}
}

测试类：

public class PolymorphicTest {

    public static void main(String[] args) {
        //创建饲养员对象
        AnimalKeeper animalKeeper = new AnimalKeeper();

        //创建宠物对象
        Cat cat = new Cat();
        animalKeeper.feed(cat);//猫吃鱼！

        Dog dog = new Dog();
        animalKeeper.feed(dog);//狗啃骨头！
    }
}

以上实现看起来没有什么问题，也容易理解，在目前情况下，饲养员可以满足喂养宠物的需求。但是，过了一周，饲养员又喂养了一只鸟，这时候不得不修改AnimalKeeper类，使其可以饲养宠物鸟，不仅违反了Java中的开闭原则，而且以上代码的实现，扩展性极差。

使用多态的实现：

只需要对以上代码中，饲养员类AnimalKeeper进行替换，新增一个饲养员类AnimalKeeperPolymorphic类。

/**
 * 饲养员
 */
public class AnimalKeeperPolymorphic {

    /**
     * 饲养员给宠物喂食
     *
     * @param animal
     */
    public void feed(Animal animal) {
        animal.eat();
    }

}

测试用例：

public static void change() {
   //创建饲养员对象
    AnimalKeeperPolymorphic animalKeeper = new AnimalKeeperPolymorphic();

    //创建宠物对象
    Cat cat = new Cat();
    animalKeeper.feed(cat);//猫吃鱼！

    Dog dog = new Dog();
    animalKeeper.feed(dog);//狗啃骨头！
}

这种实现有什么好处呢，当新需求来了，需要扩展时，不需要修改饲养员的代码。比如说刚才那个需求，新增加一个宠物鸟，只需要新建一个宠物鸟类，实现Animal接口，不仅遵循了OCP原则，也可以实现饲养宠物鸟的功能。

多态分析

以上文中示例代码进行分析，看看多态是如何使用的。

AnimalKeeperPolymorphic中的feed()方法，使用了多态。

当饲养员喂养宠物狗时，其实执行的是：

Animal animal = new Dog();

当饲养员喂养宠物猫时，其实执行的是：

Animal animal = new Cat();

这种属于向上转型，里面有继承（cat继承Animal）关系，重写了父类eat()方法，子类型赋值给父类型（父类型的引用指向子类型），构成了多态。

Animal animal = new Cat();

程序在编译阶段，animal引用类型被编译器看做Animal类型，所以程序在编译阶段，animal引用绑定的是Aninmal类中的eat()方法，这个过程叫做Java多态的静态绑定。

程序在运行的时候，堆中的对象实际上是Cat类型，而Cat对象已经覆盖（重写）了父类Animal的eat()方法，
所以程序在运行阶段，对象绑定的方法是Cat中的eat()方法，这个过程叫做Java多态的动态绑定。

相关面试题

• https://www.cnblogs.com/chenssy/p/3372798.html
• https://www.jianshu.com/p/3601dc63e5d8

注意：优先级从高到低：**this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)**。

class A { 
     public String show(D obj)...{ 
        return ("A and D"); 
     } 
     public String show(A obj)...{ 
        return ("A and A"); 
     } 
} 
class B extends A{ 
     public String show(B obj)...{ 
        return ("B and B"); 
     } 
     public String show(A obj)...{ 
        return ("B and A"); 
     } 
} 
class C extends B...{} 
class D extends B...{}

问题：以下输出结果是什么

A a1 = new A();
A a2 = new B();
B b = new B();
C c = new C();
D d = new D();
System.out.println(a1.show(b));   ①
System.out.println(a1.show(c));   ②
System.out.println(a1.show(d));   ③
System.out.println(a2.show(b));   ④
System.out.println(a2.show(c));   ⑤
System.out.println(a2.show(d));   ⑥
System.out.println(b.show(b));     ⑦
System.out.println(b.show(c));     ⑧
System.out.println(b.show(d));     ⑨ 

①   A and A
②   A and A
③   A and D
④   B and A
⑤   B and A
⑥   A and D
⑦   B and B
⑧   B and B
⑨   A and D

分析：

做这种题的话要时时刻刻使用那个优先级顺序：

对于第一题：

a1是A类的一个实例化对象，所以this指向A，然后查找this.show(b),由于没有这个方法，所以到super.show（b），但是由于A类没有超类了，所以到this.show(super b),由于b的超类是A，所以相当于this.show(A),然后在A类中查找到了这个方法，于是输出A and A。

对于第二题：

同样，a1是A类的实例化对象，所以this指向A，然后在A类中查找this.show（C）方法，由于没有这个方法，所以到了super.show(C),由于A类的超类里面找，但是A没有超类，所以到了this.show(super C)，由于C的超类是B所以在A类里面查找this.show(B)方法，也没找到，然后B也有超类，就是A，所以查找this.show(A),找到了，于是输出A and A；

对于第三题：

同样，a1是A类的实例化对象，所以this指向A，然后在A类中找到this.show(D)方法，找到了，所以就输出A and D；

对于第四题：

a2是B类的引用对象，类型为A，所以this指向A类，然后在A类里面找this.show(B)方法，没有找到，所以到了super.show(B),由于A类没有超类，所以到了this.show（super B），B的超类是A，即super B = A，所以执行方法this。show（A），在A方法里面找show（A），找到了，但是由于a2是一个类B的引用对象，而B类里面覆盖了A类的show（A）方法，所以最终执行的是B类里面的show（A）方法，即输出B and A；

对于第五题：

a2是B类的引用对象，类型为A，所以this指向A类，然后在A类里面找this.show(C)方法，没有找到，所以到了super.show（C）方法，由于A类没有超类，所以到了this.show(super C),C的超类是B，所以在A类里面找show（B），同样没有找到，发现B还有超类，即A，所以还继续在A类里面找show（A）方法，找到了，但是由于a2是一个类B的引用对象，而B类里面覆盖了A类的show（A）方法，所以最终执行的是B类里面的show（A）方法，即输出B and A；

对于第六题：

a2是B类的引用对象，类型为A，所以this指向A类，然后在A类里面找this.show(D)方法，找到了，但是由于a2是一个类B的引用对象，所以在B类里面查找有没有覆盖show（D）方法，没有，所以执行的是A类里面的show（D）方法，即输出A and D；

对于第七题：

b是B类的一个实例化对象，首相执行this.show(B)，在B类里面找show（B）方法，找到了，直接输出B and B；

对于第八题：

b是B类的一个实例化对象，首相执行this.show(C)，在B类里面找show（C）方法，没有找到，所以到了super.show(c),B的超类是A，所以在A类中找show（C）方法，没有找到，于是到了this.show(super C),C的超类是B，所以在B类中找show(B)f方法，找到了，所以执行B类中的show（B）方法输出B and B；

对于第九题：

b是B类的一个实例化对象，首相执行this.show(D)，在B类里面找show（D）方法，没有找到，于是到了super.show(D),B的超类是A类，所以在A类里面找show（D）方法，找到了，输出A and D；

方法重载 Overload

在一个类中，我们可以定义多个方法。如果有一系列方法，它们的功能都是类似的，只有参数有所不同，那么，可以把这一组方法名做成同名方法。例如，在Hello类中，定义多个hello()方法：

class Hello {
	public void hello() {
		System.out.println("Hello, world!");
	}

	public void hello(String name) {
		System.out.println("Hello, " + name + "!");
	}

	public void hello(String name, int age) {
		if (age < 18) {
			System.out.println("Hi, " + name + "!");
		} else {
			System.out.println("Hello, " + name + "!");
		}
	}
}

这种方法名相同，但各自的参数不同，称为方法重载（Overload）。

注意：方法重载的返回值类型通常都是相同的。

方法重载的目的是，功能类似的方法使用同一名字，更容易记住，因此，调用起来更简单。

覆写（Override）

在继承关系中，子类如果定义了一个与父类方法签名完全相同的方法，被称为覆写（Override）。

例如，在Person类中，我们定义了run()方法：

class Person {
    public void run() {
        System.out.println("Person.run");
    }
}

在子类Student中，覆写这个run()方法：

class Student extends Person {
    @Override
    public void run() {
        System.out.println("Student.run");
    }
}

Override和Overload不同的是，如果方法签名不同，就是Overload，Overload方法是一个新方法；
如果方法签名相同，并且返回值也相同，就是Override。

参考

• 多态
• java多态面试题
• 字节面试题-谈谈对 java 多态的理解
• Java多态性：Java什么是多态？
• java提高篇(四)—–理解java的三大特性之多态
• 深度分析：理解Java中的多态机制，一篇直接帮你掌握！