zoukankan      html  css  js  c++  java
  • Java的多态

    什么是多态?

    1. 面向对象的三大特性:封装、继承、多态。从一定角度来看,封装和继承几乎都是为多态而准备的
    2. 多态的定义指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。(发送消息就是函数调用)
    3. 实现多态的技术称为动态绑定(dynamic binding),是指在执行期间判断所引用对象的实际类型,根据其实际的类型调用其相应的方法。
    4. 多态的作用消除类型之间的耦合关系
    5. 现实中,关于多态的例子不胜枚举。比方说按下 F1 键这个动作,如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档;如果当前在 Word 下弹出的就是 Word 帮助;在 Windows 下弹出的就是 Windows 帮助和支持。同一个事件发生在不同的对象上会产生不同的结果。 

     

    Java中多态的实现方式:

      接口实现;

      继承父类进行方法重写;

      同一个类中进行方法重载。

      

    多态的特性

    1.可替换性(substitutability)。

      多态对已存在代码具有可替换性。例如,多态对圆Circle类工作,对其他任何圆形几何体,如圆环,也同样工作。
    2.可扩充性(extensibility)。

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

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

      它在应用中体现了灵活多样的操作,提高了使用效率。
    5.简化性(simplicity)。

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

    继承中的多态存在的三个必要条件:

    一、要有继承;
    二、继承后要有方法重写;
    三、方法重写后,还要有父类引用指向子类对象,从而动态地调用方法。

     

    继承中的多态的特点:

      在多态中通过引用去调用属性,如果属性存在重写,调用的都是父类型的属性,如果父类不存在该属性则会报错;

      在多态中子类如果存在方法重写的话,则会优先调用子类中的方法,如果不存在重写的话则调用父类的方法,如果父类仍然没有该方法则会报错。

     

      比如,一个酒神,对酒情有独钟而且很精通。某天你回家发现桌子上有一模一样的几个酒杯而且都装满了酒。从外面看不知道各自装的是什么酒,只有喝了之后才知道分别是:酒a = 剑南春;酒b = 五粮液;酒c = 酒鬼酒;……这个例子中表现的就是多态。剑南春、五粮液、酒鬼酒、……都是酒的子类,我们只通过酒这个父类就可以引用不同的子类,这就是多态——我们只有在运行的时候才会知道引用变量所指向的具体实例对象。

      诚然,要理解多态我们要首先明白什么是“向上转型”。例如:酒(Wine)是父类,剑南春(JNC)、五粮液(WLY)、酒鬼酒(JGJ)是子类。那么我们定义如下代码:

    JNC  a  =  new  JNC();

      这个代码我们很容易理解,就是实例化了一个剑南春的对象,如果这样:

    Wine  a  =  new  JNC();

      这里我们定义了一个Wine类型的引用变量a,它指向JNC对象实例。由于JNC是继承于Wine的,所以a是可以指向JNC对象的。这样做存在一个非常大的好处,在继承中我们知道子类是父类的扩展,它可以提供比父类更强大的功能,如果我定义了一个指向子类的父类引用类型,那么它除了能够引用父类的共性之外,还可以使用子类的强大的功能。

      但是向上转型存在一些缺憾,那就是它必定导致一些属性和方法的丢失,从而导致我们不能够获取他们。所以父类型的引用可以调用父类中定义的所有属性和方法,对于只存在于子类中的属性和方法,它就望尘莫及了。

    public class Wine {

     

               public viod fun1(){

     

                 System.out.println("Wine的fun1……");

     

                 fun2();

     

               }

     

               public viod fun2(){

     

                System.out.println("Wine的fun2……");

     

               }

     

    }

     

     

     

    public class JNC extends Wine {

     

          /*

     

           * 子类重载父类的方法

     

           * 父类中不存在该方法,

     

           * 向上转型后,父类是不能引用该方法的。

     

           * /

     

               public viod fun1(String a){

     

                 System.out.println("JNC的fun1……");

     

                 fun2();

     

               }

     

     

          /*

     

           * 子类重写父类方法

     

           * 指向子类的父类引用调用fun2时

     

           * 必定是调用该方法

     

           */

     

               public viod fun2(){

     

                System.out.println("JNC的fun2……");

     

               }

     

    }

    /* 此时在子类JNC中存在三种方法:a.继承过来的方法fun1()(和fun2());

    * b.自己的(重载的)方法fun1(String a);

    * c.自己重写的方法fun2()(原有继承过来的方法fun2()就不存在了)。

    */

         

    public class Test{

     

           public static void main(String[] args) {

     

               Wine a = new JNC();

     

               a.fun1();

     

           }

     

    }    

     

      运行输出的结果是:

          “Wine的fun1……”

           “JNC的fun2……”

     

    分析:从程序的运行结果中我们发现,a.fun1()首先是调用自己继承过来的父类wine的fun1()方法;在调用时由于fun1()方法中又有fun2()方法,但是fun2()又被子类JNC重写了,那么在调用fun1()方法后接着调用子类JNC重写以后的fun2()方法。

     

      在这个程序中子类JNC重载了父类wine的方法fun1(),重写了fun2(),而且重载后的fun1(String a)与fun1()不是同一个方法,由于父类中没有该方法,向上转型后会丢失该方法,所以执行JNC的wine类型引用变量a是不能调用该方法fun1(String a)的。而子类JNC重写了fun2(),那么指向JNC的wine引用会调用JNC中fun2()方法。

       

     

    所以,对于多态我们可以总结如下:

          指向子类的父类引用由于向上转型了,它只能访问父类中拥有的方法和属性,而对于子类中存在而父类中不存在的方法,该引用是不能使用的,即使是重载该方法。若子类重写了父类中的某些方法,在调用该些方法的时候,必定是使用子类中重写的这些方法(动态连接、动态调用)。

          对于面向对象而言,多态分为编译时多态和运行时多态。其中编译时多态是静态的,主要是指方法的重载,它是根据参数列表的不同来区分不同的函数,通过编译之后会变成两个不同的函数,在运行时谈不上多态。而运行时多态是动态的,它是通过动态绑定来实现的,也就是我们所说的多态性。

     例2:

    Public class Wine {
      private String name;
      public Wine(){};
       public String getName() {
            return name;
      }
      public void setName(String name) {
            this.name = name;
      }
      public String drink(){
            return "喝的是 " + getName();
       }
       public String toString(){
            return null;
      }
    }
     
    public class JNC extends Wine{
      public JNC(){
           setName("JNC");
      }
      public String drink(){
            return "喝的是 " + getName();
        }
        public String toString(){
            return "Wine : " + getName();
        }
    }
     
    public class JGJ extends Wine{
        public JGJ(){
            setName("JGJ");
        }
      public String drink(){
            return "喝的是 " + getName();
       }   
       public String toString(){
            return "Wine : " + getName();
       }
    }
     
    public class Test {
        public static void main(String[] args) {
            //定义父类数组
            Wine[] wines = new Wine[2];
            //定义两个子类对象
            JNC jnc = new JNC();
            JGJ jgj = new JGJ();
            //父类引用子类对象
            wines[0] = jnc;
            wines[1] = jgj;
            for(int i = 0 ; i < 2 ; i++){
                System.out.println(wines[i].toString() 
    + "--" + wines[i].drink());
            }    System.out.println("-------------------------------");
     
        }
    }

    OUTPUT:
      Wine : JNC--喝的是 JNC
      Wine : JGJ--喝的是 JGJ

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

      在上面的代码中JNC、JGJ继承Wine,并且重写了drink()、toString()方法,程序运行结果是调用子类中方法,输出JNC、JGJ的名称,这就是多态的表现。不同的对象可以执行相同的行为,但是他们都需要通过自己的实现方式来执行,这就要得益于向上转型了。

    
    

      我们都知道所有的类都继承于超类Object,toString()方法也是Object中方法,当我们这样写时:

    
    

    Object o = new JGJ();

    
    
     System.out.println(o.toString());
    
    

                            输出的结果是Wine : JGJ。

    
    

          Object、Wine、JGJ三者继承链关系是:JGJ—>Wine—>Object。所以我们可以这样说:当子类重写父类的方法被调用时,只有对象继承链中的最末端的方法才会被调用。 但是注意如果这样写:

    
    

    Object o = new Wine();

    
    
    System.out.println(o.toString());
    
    

    输出的结果应该是Null,因为JGJ并不存在于该对象继承链中。

    
    

          所以基于继承实现的多态可以总结如下:对于引用子类的父类类型,在处理该引用时,它适用于继承该父类的所有子类,子类对象的不同,对方法的实现也就不同,执行相同动作产生的行为也就不同 。

    
    

          如果父类是抽象类,那么子类必须要实现父类中所有的抽象方法,这样该父类所有的子类一定存在统一的对外接口,但其内部的具体实现可以各异。这样我们就可以使用顶层类提供的统一接口来处理该层次的方法。


    案例3
    
    
    public class A {
    
    
        public String show(D obj) {
    
    
            return ("A and D");
    
    
    }
    
    
    public String show(A obj) {
    
    
            return ("A and A");
    
    
        } 
    
    
    }
    
    
     
    
    
    public class B extends A{
    
    
        public String show(B obj){
    
    
            return ("B and B");
    
    
        }
    
    
        public String show(A obj){
    
    
            return ("B and A");
    
    
        } 
    
    
    }
    
    
     
    
    
    public class C extends B{ }
    
    
     
    
    
    public class D extends B{ }
    
    
     
    
    
    public class Test {
    
    
        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("1--" + a1.show(b));
    
    
            System.out.println("2--" + a1.show(c));
    
    
            System.out.println("3--" + a1.show(d));
    
    
            System.out.println("4--" + a2.show(b));
    
    
            System.out.println("5--" + a2.show(c));
    
    
            System.out.println("6--" + a2.show(d));
    
    
            System.out.println("7--" + b.show(b));
    
    
            System.out.println("8--" + b.show(c));
    
    
            System.out.println("9--" + b.show(d));      
    
    
        }
    
    
    }
    
    

     

    
    

     

    
    

     

    
    

    运行结果:

    
    
    1--A and A
    
    
    2--A and A
    
    
    3--A and D
    
    
     
    
    
    4--B and A
    
    
    5--B and A
    
    
    6--A and D
    
    
     
    
    
    7--B and B
    
    
    8--B and B
    
    
    9--A and D
    
    

          在这里看结果(1、2、8)、(3、9)、7好理解,从4开始就开始糊涂了,对于4来说为什么输出不是“B and B”呢?

    
    

          首先我们先看一句话:当超类对象的引用变量,引用子类对象时,被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,但是这个被调用的方法必须是在超类中定义过的,也就是说被子类覆盖的方法。这句话对多态进行了一个概括。其实在继承链中对象方法的调用存在一个优先级:this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。

    
    

     

    首先我们分析5,a2.show(c),a2是A类型的引用变量,所以this就代表了A,a2.show(c),它在A类中找发现没有找到,于是到A的超类中找(super),由于A没有超类(Object除外),所以跳到第三级,也就是this.show((super)O),C的超类有B、A,所以(super)O为B、A,this同样是A,这里在A中找到了show(A obj),同时由于a2是B类的一个引用且B类重写了show(A obj),因此最终会调用子类B类的show(A obj)方法,结果也就是B and A。

          按照同样的方法我也可以确认其他的答案。

          方法已经找到了,但是我们这里还是存在一点疑问,我们还是来看这句话:当超类对象引用变量引用子类对象时,被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,但是这个被调用的方法必须是在超类中定义过的,也就是说被子类覆盖的方法。这我们用一个例子来说明这句话所代表的含义:a2.show(b);这里a2是引用变量,为A类型,它引用的是B对象,因此按照上面那句话的意思是说由B来决定调用谁的方法,所以a2.show(b)应该要调用B中的show(B obj),产生的结果应该是“B and B”,但是为什么会与前面的运行结果产生差异呢?这里我们忽略了后面那句话但是这儿被调用的方法必须是在超类中定义过的,那么show(B obj)在A类中存在吗?根本就不存在!所以这句话在这里不适用?那么难道是这句话错误了?非也!其实这句话还隐含这这句话:它仍然要按照继承链中调用方法的优先级来确认。所以它才会在A类中找到show(A obj),同时由于B重写了该方法所以才会调用B类中的方法,否则就会调用A类中的方法

          所以多态机制遵循的原则概括为:当超类对象引用变量引用子类对象时,被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,但是这个被调用的方法必须是在超类中定义过的,也就是说被子类覆盖的方法,但是它仍然要根据继承链中方法调用的优先级来确认方法,该优先级为:this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。

    
    

     原文链接:http://blog.csdn.net/thinkGhoster/archive/2008/04/19/2307001.aspx 




  • 相关阅读:
    Android开发之Sqlite的使用
    ZOJ 3607 Lazier Salesgirl
    ZOJ 3769 Diablo III
    ZOJ 2856 Happy Life
    Ural 1119 Metro
    Ural 1146 Maximum Sum
    HDU 1003 Max Sum
    HDU 1160 FatMouse's Speed
    Ural 1073 Square Country
    Ural 1260 Nudnik Photographer
  • 原文地址:https://www.cnblogs.com/zzp-biog/p/9851656.html
Copyright © 2011-2022 走看看