JAVA多态很变态的一个题

有A类：

package cn.com.zhuansun;public class A {public String show(D obj){return "A and D";}public String show(A obj){return "A and A";}}

有B类：

package cn.com.zhuansun;public class B extends A {public String show(B obj){return "B and B";}public String show(A obj){return "B and A";}}

有C类：

package cn.com.domain;public class C extends B{}

有D类：

package cn.com.domain;public class D extends B{}

测试类：

package cn.com.domain;public class MianShow {public static void main(String[] args) {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));     //1                System.out.println(a1.show(c));     //2                System.out.println(a1.show(d));     //3                System.out.println(a2.show(b));     //4                System.out.println(a2.show(c));     //5                System.out.println(a2.show(d));     //6                System.out.println(b.show(b));      //7                System.out.println(b.show(c));      //8                System.out.println(b.show(d));      //9}}

程序运行的结果：

A and AA and AA and DB and AB and AA and DB and BB and BA and D

对于多态的理解：

这里我就多说一些（不想看这些，可以跳到最后），这个程序是我用来学习多态，在网上看到了一个程序。

（以下对多态的理解，摘自：传送）

面向对象编程有三个特征，即封装、继承和多态。

封装隐藏了类的内部实现机制，从而可以在不影响使用者的前提下改变类的内部结构，同时保护了数据。

继承是为了重用父类代码，同时为实现多态性作准备。那么什么是多态呢？

方法的重写、重载与动态连接构成多态性。Java之所以引入多态的概念，原因之一是它在类的继承问题上和C++不同，后者允许多继承，这确实给其带来的非常强大的功能，但是复杂的继承关系也给C++开发者带来了更大的麻烦，为了规避风险，Java只允许单继承，派生类与基类间有IS-A的关系（即“猫”is a “动物”）。这样做虽然保证了继承关系的简单明了，但是势必在功能上有很大的限制，所以，Java引入了多态性的概念以弥补这点的不足，此外，抽象类和接口也是解决单继承规定限制的重要手段。同时，多态也是面向对象编程的精髓所在。

要理解多态性，首先要知道什么是“向上转型”。

我定义了一个子类Cat，它继承了Animal类，那么后者就是前者是父类。我可以通过

Cat c = new Cat();
实例化一个Cat的对象，这个不难理解。但当我这样定义时：

Animal a = new Cat();
这代表什么意思呢？

很简单，它表示我定义了一个Animal类型的引用，指向新建的Cat类型的对象。由于Cat是继承自它的父类Animal，所以Animal类型的引用是可以指向Cat类型的对象的。那么这样做有什么意义呢？因为子类是对父类的一个改进和扩充，所以一般子类在功能上较父类更强大，属性较父类更独特，

定义一个父类类型的引用指向一个子类的对象既可以使用子类强大的功能，又可以抽取父类的共性。

所以，父类类型的引用可以调用父类中定义的所有属性和方法，而对于子类中定义而父类中没有的方法，它是无可奈何的（说白了，就是用不了，记住这点！！）；

同时，父类中的一个方法只有在在父类中定义而在子类中没有重写的情况下，才可以被父类类型的引用调用；

对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将会调用子类中的这个方法，这就是动态连接。

对于程序运行结果的解释：

1：实例对象是A，参数对象是B，没有对应的方法，找B的父类，是A，所以就找到了show(A obj)-----> 输出：A and A；

2：实例对象是A，参数对象是C，没有对应的方法，找C的父类，是B，没有对应的方法，在往上找父类，是A，所以使用show(A obj)-----> 输出：A and A；

3：实例对象是A，参数对象是D，有对应的方法，所以使用show(D obj)---->输出：A and D；

4：实例对象是A（虽然new的是B，但是转成了A），参数对象是B，【由于子类中独有，父类中没有的方法，向上转型后，父类是不能调用该方法的。同时，如果子类重写了父类中的某一个方法，那么调用的时候，调用的是子类中的方法】，所以使用B类中的show(A obj)------->输出：B and A；

补充：对于本例中A a2 = new B()， a2中能使用的方法就只有两个：show(D obj),  show(A obj)

5：实例对象是A，参数对象是C，没有对应的方法，对C找父类，所以使用show(A obj)------->输出：B and A；

6：实例对象是A，参数对象是D，有对应的方法，直接使用show(D obj)------->输出：A and D；

7：实例对象是B，参数对象是B，有对应的方法，直接使用show(B obj)------->输出：B and B；

8：实例对象是B，参数对象是C，没有对应的方法，对C找父类，是B，有对应的方法，所以使用show(B obj)------->输出：B and B；

9：实例对象是B，参数对象是D，【由于B是继承A，所以A中public的方法，在B中可以用】，这样就有了对应的方法，所以使用A中的show(D obj)------->输出：A and D；

【完】2017年5月14日19:57:54