JAVA 多态 由浅及深介绍

什么是多态?

     

多态分两种：

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

 

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

 

运行时多态存在的三个必要条件：
一、要有继承（包括接口的实现）；
二、要有重写；
三、父类引用指向子类对象。

 

--------------------------------------------------------------------------------

 

详细解释：

 

运行时多态的解释：a.运行时多态是指程序中定义的引用变量所指向的具体类型和b.通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定.

 

1.程序序中定义的引用变量所指向的具体类型不确定(即一个引用变量倒底会指向哪个类的实例对象) 。
 

例子 ：

driver 类中 drive 方法 （vehicle类 vehicle）{}

•onedriver.drive( new car() )
•onedriver.drive( new bus() )
其中vehicle 变量无法确定具体使用哪个子类实例。

 

1.通过该引用变量发出的方法调用在编程时并不确定(该引用变量发出的方法调用到底是哪个类中实现的方法) 。
 

例子 : 厨师，园丁，理发师的cut 方法调用.persion.cut().

 

--------------------------------------------------------------------------------

 

 

多态的好处：

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

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

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

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

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

 

 

实际运用：

结合配置文件的使用，联系spring框架，利用反射，动态的调用类，同时不用修改源代码，直接添加新类和修改配置文件，不需要重启服务器便可以扩展程序。

 

--------------------------------------------------------------------------------

 

小结：

使用父类类型的引用指向子类的对象，该引用调用的师父类中定义的方法和变量，变量不能被重写（覆盖）；如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；

         注意特殊情况，如果该父类引用所调用的方法参数列表未定义，就调用该父类的父类中查找，如果还没找到就强制向上类型转换参数列表中的参数类型，具体优先级高到低依次如下：

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

（四）分析

        ①②③比较好理解，一般不会出错。④⑤就有点糊涂了，为什么输出的不是"b and b”呢？！！先来回顾一下多态性。

        运行时多态性是面向对象程序设计代码重用的一个最强大机制，动态性的概念也可以被说成“一个接口，多个方法”。java实现运行时多态性的基础是动态方法调度，它是一种在运行时而不是在编译期调用重载方法的机制。

        方法的重写overriding和重载overloading是java多态性的不同表现。重写overriding是父类与子类之间多态性的一种表现，重载overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写(overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(overloading)。overloaded的方法是可以改变返回值的类型但同时参数列表也得不同。

        当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。 （但是如果强制把超类转换成子类的话，就可以调用子类中新添加而超类没有的方法了。）

        好了，先温习到这里，言归正传！实际上这里涉及方法调用的优先问题 ，优先级由高到低依次为：this.show(o)、super.show(o)、this.show((super)o)、super.show((super)o)。让我们来看看它是怎么工作的。

        比如④，a2.show(b)，a2是一个引用变量，类型为a，则this为a2，b是b的一个实例，于是它到类a里面找show(b obj)方法，没有找到，于是到a的super(超类)找，而a没有超类，因此转到第三优先级this.show((super)o)，this仍然是a2，这里o为b，(super)o即(super)b即a，因此它到类a里面找show(a obj)的方法，类a有这个方法，但是由于a2引用的是类b的一个对象，b覆盖了a的show(a obj)方法，因此最终锁定到类b的show(a obj)，输出为"b and a”。

        再比如⑧，b.show(c)，b是一个引用变量，类型为b，则this为b，c是c的一个实例，于是它到类b找show(c obj)方法，没有找到，转而到b的超类a里面找，a里面也没有，因此也转到第三优先级this.show((super)o)，this为b，o为c，(super)o即(super)c即b，因此它到b里面找show(b obj)方法，找到了，由于b引用的是类b的一个对象，因此直接锁定到类b的show(b obj)，输出为"b and b”。

        按照上面的方法，可以正确得到其他的结果。

        问题还要继续，现在我们再来看上面的分析过程是怎么体现出蓝色字体那句话的内涵的。它说：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。还是拿a2.show(b)来说吧。

        a2是一个引用变量，类型为a，它引用的是b的一个对象，因此这句话的意思是由b来决定调用的是哪个方法。因此应该调用b的show(b obj)从而输出"b and b”才对。但是为什么跟前面的分析得到的结果不相符呢？！问题在于我们不要忽略了蓝色字体的后半部分，那里特别指明：这个被调用的方法必须是在超类中定义过的，也就是被子类覆盖的方法。b里面的show(b obj)在超类a中有定义吗？没有！那就更谈不上被覆盖了。实际上这句话隐藏了一条信息：它仍然是按照方法调用的优先级来确定的。它在类a中找到了show(a obj)，如果子类b没有覆盖show(a obj)方法，那么它就调用a的show(a obj)（由于b继承a，虽然没有覆盖这个方法，但从超类a那里继承了这个方法，从某种意义上说，还是由b确定调用的方法，只是方法是在a中实现而已）；现在子类b覆盖了show(a obj)，因此它最终锁定到b的show(a obj)。这就是那句话的意义所在。