当前位置:

首页 > 编程开发 > Java教程 >

多态

一.相关定义

1-1 多态

　　多态是同一个行为具有多个不同表现形式或形态的能力。同一个形参类型为基类的接口，使用不同的子类的实例可以执行不同操作。

1-2 绑定

绑定：将一个方法调用和一个方法体关联起来被称作绑定；
前期绑定：若在程序执行前进行绑定（如果有的话，由编译器和连接程序实现）；
后期绑定：在运行时根据对象的类型绑定，也叫做动态绑定或运行时绑定。

　　后期绑定的实现通常是在对象中安置某种“类型信息”，以便方法调用机制能知道对象是哪种类型，从而找到对应的方法体加以调用。

　　Java中除了static方法和final方法（private方法也属于final方法）之外，其他所有方法都是后期绑定。

1-3 总是调用最派生的方法

　　Java在使用基类引用调用方法时，总是调用最派生的方法。选取最派生方法的范围是：基类中的方法和基类引用指向的对象所在类中覆写的同名方法。即，如果基类引用所指向对象所在的类中未覆写基类中的方法，那么通过基类引用调用的将会是基类中的方法，否则调用的就是基类引用所指向对象所在类中覆写的方法。

package com.hutao.test.page155;

import static com.hutao.util.Print.print;

class BaseClass {
    public void method1(){
        print("Base class's method1 call method2");
        method2();
    }

    public void method2(){
        print("Base class's method2 was called");
    }
}

class DerivedClass extends BaseClass{
    @Override
    public void method2() {
        print("Derived class's method2 was called");
    }
}

public class Test{
    public static void main(String[] args) {
        BaseClass baseClass = new DerivedClass();
        //使用基类引用调用方法
        baseClass.method1();
    }
}

运行结果为：

Base class's method1 call method2
Derived class's method2 was called

Process finished with exit code 0

如上代码中的派生关系为：

使用基类引用调用的方法是method1()，从BaseClass baseClass = new DerivedClass()可知选取最派生方法的范围应该是BaseClass类和DerivedClass类，但DerivedClass中未覆写BaseClass中的method1()，所以最派生的method1()方法就是BaseClass中的method1()。BaseClass中的method1()又调用了method2()，这里实际上也可理解为是通过基类引用baseClass去调用的method2()，此时，因为DerivedClass中覆写了method2()，所以选取最派生的方法就是DerivedClass类中的method2()。

二.final方法、静态方法和域的多态

　　结论：final方法（包括private方法）、静态方法和域没有多态特性。

2-1 final方法

　　final方法不可以被覆写，所以同一个行为就不能有多种表现形式，所以没有多态。注意：private方法是默认的final方法。

package com.hutao.page.page156;
import static com.hutao.util.Print.*;

public class PrivateOverride {
    private void f(){
        print("private f()");
    }

    public static void main(String[] args) {
        PrivateOverride privateOverride = new Derived();
        privateOverride.f();
    }
}

class Derived extends PrivateOverride{
    public void f(){
        print("public f()");
    }
}

运行结果为：

private f()

Process finished with exit code 0

这里还是可以根据1-3中的方式分析，从PrivateOverride privateOverride = new Derived()中可知，选取最派生f()方法的范围为PrivateOverrie类和Derived类，但是Derived类中未覆写f()方法（虽然有同名方法，但因为private方法不可能被覆写，所以Derived类中的f()只能算是另一个新方法），所以选取的范围就只剩下来基类中的f()方法，因此实际调用的方法就是基类中的f()方法。

2-2 静态方法

　　静态方法对应的行为不具有多态性，静态方法是与类而并非单个对象关联的。

package com.hutao.page.page157;

class StaticSuper{
    public static String staticGet(){
        return "Base staticGet()";
    }
    public String dynamicGet(){
        return "Base dynamicGet()";
    }
}

class StaticSub extends StaticSuper{
    public static String staticGet(){
        return "Derived staticGet()";
    }
    public String dynamicGet(){
        return "Derived dynamicGet()";
    }
}

public class StaticPolymorphism {
    public static void main(String[] args) {
        //静态方法是与类而并非单个对象关联的，所以这里的静态方法会与引用的类型StaticSuper类相关联
        StaticSuper staticSuper = new StaticSub();
        System.out.println(staticSuper.staticGet());
        System.out.println(staticSuper.dynamicGet());
    }
}

运行结果为：

Base staticGet()
Derived dynamicGet()

Process finished with exit code 0

2-3 域

　　如果直接访问某个域，这个访问在编译期就进行了解析（并非是运行时绑定），所以域不具有多态性。

package com.hutao.page.page156;

class Super{
    public int field = 0;
    public int getField(){
        return field;
    }
}

class Sub extends Super{
    public int field = 1;
    public int getField(){
        return field;
    }
    public int getSupperField(){
        return super.field;
    }
}

public class FieldAccess {
    public static void main(String[] args) {
        Super sup = new Sub();//upcast
        System.out.println("sup.field = "+sup.field +
                ", sup.getField() = "+sup.getField());

        Sub sub = new Sub();
        System.out.println("sub.field = "+sub.field+
                ", sub.getField() = "+sub.getField()+
                ", sub.getSuperField() = "+sub.getSupperField());
    }
}

运行结果为：

sup.field = 0, sup.getField() = 1
sub.field = 1, sub.getField() = 1, sub.getSuperField() = 0

Process finished with exit code 0

三.构造器和多态

3-1 构造器的多态

构造器不具有多态性，因为构造器实际上是隐式声明的static方法，由2-2可知，静态方法不具有多态性。

基类的构造器总是在导出类的构造过程中被调用；
无论是基类还是导出类，在构造器被调用时，所有成员变量都已经完成了初始化。

package com.hutao.page.page158;
import static com.hutao.util.Print.*;

class Meal{
    Meal(){
        print("Meal()");
    }
}

class Bread{
    Bread(){
        print("Bread()");
    }
}

class Cheese{
    Cheese(){
        print("Cheese()");
    }
}

class Lettuce{
    Lettuce(){
        print("Lettuce()");
    }
}

class Lunch extends Meal{
    Lunch(){
        print("Lunch()");
    }
}

class PortableLunch extends Lunch{
    //此成员变量用来验证是先初始化成员再调用构造器的。
    private Bread bread = new Bread();

    PortableLunch(){
        print("PortableLunch()");
    }
}

public class Sandwich extends PortableLunch{
    private Bread bread = new Bread();
    private Cheese cheese = new Cheese();
    private Lettuce lettuce = new Lettuce();
    public Sandwich(){
        print("Sandwich()");
    }

    public static void main(String[] args) {
        new Sandwich();
    }
}

运行结果为：

Meal()
Lunch()
Bread()//表明成员被初始化在构造器被调用之前

PortableLunch()
Bread()
Cheese()
Lettuce()
Sandwich()

Process finished with exit code 0

调用构造器的顺序为：

1）调用基类构造器。这个步骤会不断反复递归下去，首先是构造这个层次结构的根（根基类），然后是下一层的导出类，直到最低层的导出类（构造器执行前需保证类中的所有成员按声明顺序完成了初始化）；

2）按声明顺序调用最低层导出类的初始化方法；

3）调用最低层导出类构造器的主体。

3-2 基类构造器中调用具有多态特性的方法

如果要在基类构造器中调用一个可被动态绑定的方法，实际上调用时绑定的方法体可能会是导出类中覆盖此方法的方法体。这个调用结果可能会引发错误，因为在调用基类构造器时，导出类对象还未被完全构造。（在构造导出类对象时候，会先调用基类的构造器。）

package com.hutao.page.page163;
import static com.hutao.util.Print.*;

class Glyph{
    void draw(){
        print("Glyph.draw()");
    }

    Glyph(){
        print("Glyph() before draw()");
        draw();
        print("Glyph() after draw()");
    }
}

class RoundGlyph extends Glyph{
    private int radius = 1;

    RoundGlyph(){
        this.radius = radius;
        print("RoundGlyph.RoundGlyph(), radius = "+radius);
    }

    @Override
    void draw() {
        print("RoundGlyph.draw(), radius = "+radius);
    }
}

public class PolyConstructors {
    public static void main(String[] args) {
        new RoundGlyph();
    }
}

运行结果为：

Glyph() before draw()
RoundGlyph.draw(), radius = 0
Glyph() after draw()
RoundGlyph.RoundGlyph(), radius = 1

Process finished with exit code 0

Glyph.draw()方法设计为将要被覆盖，这种覆盖是在RoundGlyph中发生的。但是Glyph构造器会调用这个方法，结果导致了对RoundGlyph.draw()的调用。但是此时RoundGlyph中的radius还未被初始化（还是二进制0）。

初始化的具体过程：（->）https://www.cnblogs.com/certainTao/p/14657469.html

编写构造器的准则：用尽可能简单的方法使对象进入正常状态；如果可以的话，避免调用其他方法。

在构造器中唯一能够安全调用的方法是本类中的final方法（private方法默认是final方法），这类方法不能被覆盖（其实调用静态方法也是可以的，但这里要表明的重点不是这个）。

来源：https://www.cnblogs.com/certainTao/p/14798451.html

栏目列表