深入理解 Java 的三大特性之多态

世界上最美丽的东西,看不见也摸不着,要靠心灵去感受。 ——海伦·凯勒


面向对象编程有三大特性:封装、继承、多态。

封装隐藏了类的内部实现机制,可以在不影响使用的情况下改变类的内部结构,同时也保护了数据。对外界而言它的内部细节是隐藏的,暴露给外界的只是它的访问方法。

继承是为了重用父类代码。两个类若存在IS-A的关系就可以使用继承。同时继承也为实现多态做了铺垫。那么什么是多态呢?多态的实现机制又是什么?

1  定义

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

因为在程序运行时才确定具体的类,这样,不用修改源程序代码,就可以让引用变量绑定到各种不同的类实现上,从而导致该引用调用的具体方法随之改变,即不修改程序代码就可以改变程序运行时所绑定的具体代码,让程序可以选择多个运行状态,这就是多态性。

2  多态的实现

2.1 实现的条件

Java实现多态有三个必要条件:继承、重写、向上转型(父类引用指向子类对象)

继承:在多态中必须存在有继承关系的子类和父类。

重写:子类对父类中某些方法进行重新定义,在调用这些方法时就会调用子类的方法。

向上转型:在多态中需要将子类的引用赋给父类对象,只有这样该引用才能够具备技能调用父类的方法和子类的方法。

只有满足了上述三个条件,我们才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象,从而达到执行不同的行为。

对于Java而言,多态的实现机制遵循一个原则:当超类对象引用变量引用子类对象时,被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,但是这个被调用的方法必须是在超类中定义过的,也就是说被子类覆盖的方法。

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

2.2 实现的方式
2.2.1、基于继承实现的多态

基于继承的实现机制主要表现在父类和继承该父类的一个或多个子类对某些方法的重写,多个子类对同一方法的重写可以表现出不同的行为。

    public class Wine {
        private String name;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Wine(){
        }
    
        public String drink(){
            return "喝的是 " + getName();
        }
    
        /**
         * 重写toString()
         */
        public String toString(){
            return null;
        }
    }
    
    public class JNC extends Wine{
        public JNC(){
            setName("JNC");
        }
    
        /**
         * 重写父类方法,实现多态
         */
        public String drink(){
            return "喝的是 " + getName();
        }
    
        /**
         * 重写toString()
         */
        public String toString(){
            return "Wine : " + getName();
        }
    }
    
    public class JGJ extends Wine{
        public JGJ(){
            setName("JGJ");
        }
    
        /**
         * 重写父类方法,实现多态
         */
        public String drink(){
            return "喝的是 " + getName();
        }
    
        /**
         * 重写toString()
         */
        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 中方法,当我们如下这样写时,输出的结果是 Wine : JGJ。

Object o = new JGJ();

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

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

Object o = new Wine();

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

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

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

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

2.2.2、基于接口实现的多态

继承是通过重写父类的同一方法的几个不同子类来体现的,那么也就是通过实现接口并覆盖接口中同一方法的几不同的类体现的。

在接口的多态中,指向接口的引用必须是指定实现了该接口的一个类的实例程序,在运行时,根据对象引用的实际类型来执行对应的方法。

继承都是单继承,只能为一组相关的类提供一致的服务接口。但是接口可以是多继承多实现,它能够利用一组相关或者不相关的接口进行组合与扩充,能够对外提供一致的服务接口。所以它相对于继承来说有更好的灵活性。

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(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©,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)。这就是那句话的意义所在。

4  总结

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

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

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


本文主要参考来源:
https://blog.csdn.net/thinkghoster/article/details/2307001
http://cmsblogs.com/?p=52

欢迎扫码关注我的公众号「蜗牛永动机」,回复 1024 免费获取 5G 编程学习资源~

​​在这里插入图片描述

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值