Java中前期绑定和后期绑定的一些经典例子

原创 2015年11月19日 23:17:43
1、关于数据成员前期绑定的一个例子
理论点:见《Java的前期绑定和后期绑定》
代码内容如下:
package com.dslztx.package1;

public class A {
    public int a = 100;

    int b = 100;
}
package com.dslztx.package2;
import com.dslztx.package1.A;

public class B extends A {
    private int a = 50;

    public static void main(String[] args) {
        B b = new B();
        //"b.a"最后绑定的是"private int a = 50;(定义地址:package2:B,目标地址:package2:B)"
        System.out.println(b.a);

        A a = new B();
        //"a.a"最后绑定的是"public int a = 100;(定义地址:package1:A,目标地址:package1:A)"
        System.out.println(a.a);

        C c = new C();
        //"c.a"最后绑定的是"private int a = 60;(定义地址:package2:C,目标地址:package2:C)",接着进行访问控制判断(注意这里的访问者地址是:package2:B,而不是:package2:C),不能访问,编译出错
        //System.out.println(c.a);

        //"c.b"最后绑定的是"int b = 60;(定义地址:package2:C,目标地址:package2:C)"
        System.out.println(c.b);

        A aa = new C();
         //"aa.a"最后绑定的是"public int a = 100;(定义地址:package1:A,目标地址:package1:A)"
        System.out.println(aa.a);
    }
}

class C extends A {
    private int a = 60;
    
    int b = 60;
}
类B运行后,结果如图1所示:
                                           图1


2、构造器方法调用过程中的多态现象
理论点:初始化顺序+一般方法的多态
代码内容如下:[1]

package com.dslztx.package1;

class Glyph {
    void draw() {
        System.out.println("Glyph.draw()");
    }

    Glyph() {
     //以下被标记为A语句块
        System.out.println("Glyph() before draw()");
        draw();
        System.out.println("Glyph() after draw()");
    }
}

class RoundGlyph extends Glyph {
    private int radius = 1;

    RoundGlyph(int r) {
     //以下被标记为B语句块
        radius = r;
        System.out.println("RoundGlyph.RoundGlyph(),radius=" + radius);
    }

    void draw() {
        System.out.println("RoundGlyph.draw(),radius=" + radius);
    }
}

/**
 * 0、注意以下不包括静态初始化过程
 * 1、首先生成RoundGlyph的实例和被包含的Glyph的实例,一旦生成好它们的实例,紧接着进行它们的非静态数据成员的默认初始化,因此radius=0
 * 2、执行RoundGlyph()构造方法
 * 2.1、首先调用父类Glyph的构造方法
 * 2.1.1、Glyph没有父类,调用Glyph父类构造方法没有效果(这里不考虑Object类)
 * 2.1.2、触发Glyph类"非静态数据成员定义初始化"的语句
 * 2.1.3、触发Glyph类"非静态数据成员初始化语句"的语句
 * 2.1.4、执行A语句块,当执行"draw()"方法,结合后期绑定的具体策略,最终执行外围子实例(即RoundGlyph实例)的"draw()"方法,此时radius=0
 * 2.2、触发RoundGlyph类"非静态数据成员定义初始化"的语句
 * 2.3、触发RoundGlyph类"非静态数据成员初始化语句"的语句
 * 2.4、执行B语句块
 */
public class PolyConstructors {
    public static void main(String[] args) {
        new RoundGlyph(5);
    }
}
类PolyConstructors运行后,结果如图2所示:

                                        图2


3、3层关系的多态现象

理论点:多层继承关系下的多态,即后期绑定的递归
代码内容如下:
package com.dslztx.package1;

public class ThreeLevel {
    public static void main(String[] args) {
        GrandFather grandFather = new Child();
        grandFather.f();
    }
}

class GrandFather {
    public void f() {
        System.out.println("GrandFather");
    }
}

class Parent extends GrandFather {
}

class Child extends Parent {
    public void f() {
        System.out.println("Child");
    }
}

类ThreeLevel运行后,结果如图3所示:

                                            图3


4、后期绑定陷阱

以下例子中,E中的f()方法和F中的f()方法不是“被覆盖”和“覆盖”的关系,E中的g()方法和F中的g()方法也不是“被覆盖”和“覆盖”的关系。最后的运行结果见图4,表明没有多态行为。原因详见《Java的前期绑定和后期绑定》,跟其中的“二、后期绑定”下的例3相类似。

package com.dslztx.package3;
import com.dslztx.package2.F;

public class E {
    private void f() {
        System.out.println("Hello");
    }

    void g() {
        System.out.println("Hello");
    }

    public static void main(String[] args) {
        E e = new F();
        e.f();
        e.g();
    }
}
package com.dslztx.package2;
import com.dslztx.package3.E;

public class F extends E {
    public void f() {
        System.out.println("World");
    }

    public void g() {
        System.out.println("World");
    }
}
                                           图4




[1]摘自《Java编程思想》

版权声明:本文为博主原创文章,未经博主允许不得转载。

Java的前期绑定和后期绑定[新]

前言:本文需要《Java类的实际定义和类资源名称冲突解决》文章的内容作为前导知识。 涉及到继承,可能使得待访问的类资源有多个定义,那么该何时和如何确定具体访问哪个定义呢?这个过程就是绑定过程。绑...
  • DSLZTX
  • DSLZTX
  • 2015年12月31日 19:47
  • 1311

java之编译时类型(前期绑定)和运行时类型 (后期绑定、动态绑定、运行时绑定)

编译时类型和运行时类型:     Java的引用变量有两个类型,一个是编译时类型,一个是运行时类型,编译时类型由声明该变量时使用的类型决定,运行时类型由实际赋给该变量的对象决定。如果编译时类型和...
  • li_zhenxing
  • li_zhenxing
  • 2014年05月06日 21:16
  • 1166

.Net中的早期绑定和后期绑定(二)

上篇介绍了.Net中绑定的故事背景,在文章的末尾引出了“早期绑定和后期绑定”,那么本文就针对.Net中的绑定做一个简单的介绍。    早期绑定    早期绑定:如果在编译时 .Net 能够知道属性或方...
  • u013035924
  • u013035924
  • 2015年05月17日 18:55
  • 1215

[Think in java] 前期绑定和后期绑定(转)

程序绑定的概念:   绑定指的是一个方法的调用与方法所在的类(方法主体)关联起来。对java来说,绑定分为静态绑定和动态绑定;或者叫做前期绑定和后期绑定 静态绑定(早绑定 编译器绑定):   在...
  • hirozing
  • hirozing
  • 2013年08月13日 20:14
  • 332

java 的前期绑定和后期绑定

java的前期绑定在程序执行前根据编译时类型绑定,调用开销较小,如C语言只有前期绑定这种方法调用 后期绑定,是指在运行时根据对象的类型进行绑定,又叫动态绑定或运行时绑定。实现后期绑定,需要某种机...
  • u014112584
  • u014112584
  • 2015年01月12日 13:55
  • 489

java的前期绑定和后期绑定使用示例

java的前期绑定在程序执行前根据编译时类型绑定,调用开销较小,如C语言只有前期绑定这种方法调用后期绑定,是指在运行时根据对象的类型进行绑定,又叫动态绑定或运行时绑定。 实现后期绑定,需要某种机制支持...
  • Allen_Infosys
  • Allen_Infosys
  • 2015年12月18日 11:10
  • 214

Java的前期绑定和后期绑定[新]

前言:本文需要《Java类的实际定义和类资源名称冲突解决》文章的内容作为前导知识。 涉及到继承,可能使得待访问的类资源有多个定义,那么该何时和如何确定具体访问哪个定义呢?这个过程就是绑定过程。绑...
  • DSLZTX
  • DSLZTX
  • 2015年12月31日 19:47
  • 1311

Java前期(静态)绑定和后期(动态)绑定

转自:http://www.cnblogs.com/jstarseven/articles/4631586.html 程序绑定的概念: 绑定指的是一个方法的调用与方法所在的类(方法主体...
  • oxiangyao
  • oxiangyao
  • 2017年03月22日 21:36
  • 76

Java前期(静态)绑定和后期(动态)绑定

Java前期(静态)绑定和后期(动态)绑定 程序绑定的概念: 绑定指的是一个方法的调用与方法所在的类(方法主体)关联起来。对java来说,绑定分为静态绑定和动态绑定;或者叫做前期绑定和后期...
  • evilcry2012
  • evilcry2012
  • 2017年11月03日 13:17
  • 45

java的前期绑定和后期绑定

原文地址:http://blog.sina.com.cn/s/blog_600046120100wdza.html 程序绑定的概念: 绑定指的是一个方法的调用与方法所在的类(方法主体)关联...
  • ziyunyangyong
  • ziyunyangyong
  • 2012年09月01日 09:36
  • 536
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Java中前期绑定和后期绑定的一些经典例子
举报原因:
原因补充:

(最多只允许输入30个字)