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
  • 1074

java的前期绑定和后期绑定

原文地址:http://blog.sina.com.cn/s/blog_600046120100wdza.html 程序绑定的概念: 绑定指的是一个方法的调用与方法所在的类(方法主体)关联...

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

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

java 的前期绑定和后期绑定

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

Java动态(后期)绑定和overloading 向上转型

动态绑定:意味着 目前正在调用的方法正是最适用于要操作对象的那个方法。然而它并不意味着对所有的参数都执行最佳匹配。 在Java中,一个方法的参数在编译阶段常被静态地绑定。 一个例子:动态绑定和...

Java之前期绑定,后期绑定,简单理解和实例

开心一笑【今天我对老公撒娇:老公你夸夸我呗!老公面无表情的看看我,一言不发。我有点生气,怎么遭,以前叫你夸我,你还会随便敷衍几句,现在连敷衍都不想了吗?老公:随便你怎么说,我只是觉得不配跟仙女说话!】...

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

编译时类型和运行时类型:     Java的引用变量有两个类型,一个是编译时类型,一个是运行时类型,编译时类型由声明该变量时使用的类型决定,运行时类型由实际赋给该变量的对象决定。如果编译时类型和运行...

java运行时多态,后期绑定的初始化顺序

package polymorphism.rodent; import static net.mindview.util.Print.*; class Characteristic { p...

Java动态绑定和内联

  • 2014-09-09 23:22
  • 958KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

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