对象多态性

多态性，是面向对象的最后一个特征，也是最重要的特征，掌握多态性可以设计更好的程序结构。

实际上方法的重载就是一种多态性的体现：

       方法名称相同，根据传入参数的类型或个数的不同完成的功能也不同。

另外一种多态性就是指的对象的多态性：

       · 子类对象向父类对象转型（向上转型）

       · 父类对象向子类对象转型（向下转型）

       · 对象间的互相转型问题

<b>强调：</b>

       一个类绝对不能继承一个已经实现好了的类。此处讲解的时候只是为了阐述概念，才使用了类与类的直接继承，但是开发中此种类型的代码肯定不存在。

       观察以下程序，初步认识对象的转型：

class A{

         public void fun1(){

                   System.out.println("A --&gt; public void fun1(){}") ;

         }

         public void fun2(){

                   this.fun1() ;

};

class B extends A{

                   System.out.println("B --&gt; public void fun1(){}") ;

         public void fun3(){

                   System.out.println("B --&gt; public void fun3(){}") ;

       以上代码可以发现，子类B，继承了父类A，同时在子类中覆写了类A中的fun1方法，也增加了自己新的fun3方法。

                   System.out.println("A1 --&gt; public void fun1(){}") ;

                   System.out.println("B1 --&gt; public void fun1(){}") ;

                   System.out.println("B2 --&gt; public void fun3(){}") ;

public class Demo10{

         public static void main(String args[]){

                   A a = new B() ;

                   a.fun1() ;

                   a.fun2() ;

       以上代码，无论是直接使用子类，还是子类向父类转型，发现最终结果调用的都是被子类覆写过的方法。

       向上转型的关系：只要发生了向上转型，则一切的操作方法以子类为标准。

       如果向上转型完成之后，那么一定可以把父类对象变为子类对象。但是此时就需要强制了。

                   B b = (B)a ;

                   b.fun1() ;

                   b.fun2() ;

       现在观察以下代码：

public class Demo11{

<b>                   A a = new A() ;</b>

<b>                   B b = (B)a ;</b>

<b>java.lang.ClassCastException</b><b>：</b>

       为类型转换异常。两个没有任何关系的对象直接进行转型了，就出现此错误。

<b>注意：</b>

       如果要进行向下转型之前，首先必须建立关系，即：必须先发生向上转型之后，才可以进行向下转型。为了建立关系。

<b>对象多态性所带来的好处？</b>

       对象多态性在传递参数上可以体现出其优点，下面看两组代码，第一组是没有使用对象多态性的时候：

class C extends A{

                   System.out.println("C1 --&gt; public void fun1(){}") ;

                   System.out.println("C2 --&gt; public void fun3(){}") ;

public class Demo12{

                   fun(new B()) ;

                   fun(new C()) ;

         // 定义一个方法，此方法可以接收A的子类对象

         public static void fun(B b){

         public static void fun(C c){

                   c.fun2() ;

       如果代码按以上格式编写会有那些问题？

       · 每增加一个子类，就要增加一个方法，所以可以发现代码重复修改。

       如果此时使用了对象多态性的概念，则代码可以修改为以下结构（所有的操作方法以被子类覆写过的方法为标准操作）：

public class Demo13{

         // 不管有多少个子类，都用父类对象接收，因为可以自动发生向上转型关系

         public static void fun(A a){

       <b>感觉到一点：</b>在继承关系中，父类的设计是最重要的，只要父类把功能定义好了，则所有代码都好写。

       <b>新的要求：</b>

              现在希望可以对程序的功能稍微有一些扩充，判断，如果传入的是B类对象，则可以调用fun3方法，如果传入的是C类对象，也可以调用C类的fun3方法。

       要完成此功能，肯定要使用向上转型。

       要完成此功能，必须对传入对象的类型进行判断，判断此对象到底是属于那个类的实例。

instanceof关键字完成：

       · 功能：判断一个对象是否是某个类的实例，返回boolean

       · 语法：对象 instanceof 类

public class Demo14{

                   if(<b>a instanceof B</b>){

                            B b = (B)a ;

                            b.fun3() ;

                   }

                   if(<b>a instanceof C</b>){

                            C c = (C)a ;

                            c.fun3() ;

<b>转型原则：</b>

       在转型之前最好先判断一下一个对象是否是某个类的实例，判断通过之后在进行向下转型操作。

转型概念清楚之后就可以利用此概念完善抽象类与接口。

本文转自 李兴华 51CTO博客，原文链接：http://blog.51cto.com/lixinghua/91245，如需转载请自行联系原作者