Java多态详解

引言

今天在写代码的时候突然看到一个堆多态的详解,说的很详细,没错是我看一遍看不懂的那种.本以为自己对多态还是比较了解的,但是看了下面这道面试题我沉默了

面试题

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 a = new B();
用通俗的话讲:用A来规范B对象的方法

在看下真正的什么是多态
大家肯定都知道,下面这个用法,为什么要这么用呢?

List<String>  list = new ArrayLsit<>();

ArrayList是继承了List接口大家都知道,List接口中有一些通用的方法,但是很多地方要的根本并不是需要ArrayList这个类的对象,为了实现灵活使用上面的写法,这样ArrayList实例化出来的对象其方法就只有List接口中的那些方法了,ArrayList中一些其独有的方法就直接不被引用了,这样的好处就是假如另一个地方需要用到LinkList也可以轻松的转换.便于程序代码的重构,这就是面向接口编程的好处

分类

多态分为两种

1. 编译时多态: 方法的重载

2. 运行时多态: 就是上面说的那种

多态的特点

当然,下面的面试的话要背过,打工人读个大体意思即可

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

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

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

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

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

解题吧!!

如果你第一次接触多态,建议不要看下面这题,先多看看上面弄懂逻辑

我再复制一份方便看

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...{}

Main函数

		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

首先有个顺序需要知晓:
注意: 优先级从高到低：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)

对于第一题：

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©,由于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©方法，没有找到，所以到了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©，在B类里面找show（C）方法，没有找到，所以到了super.show©,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；