JAVA访问控制符和动态绑定

 

首先从一道面试题目谈起:

package pkg1; public class Jupiter { void method1(){ System.out.println("In Jupiter"); } public void call(){ method1(); } } package pkg2; import pkg1.Jupiter; public class Minerva extends Jupiter{ public void method1(){ System.out.println("In Minerva"); } public static void main(String[] args) { new Minerva().call(); } }

这个程序的运行结果是（请选择）：
A 编译错误
B In Jupiter
C In Minerva
D In Jupiter 

  In Minerva

运行结果是B.

原因：父类Jupiter中的method1方法的修饰符为default,即friendly，而子类跟父类不在同一个包中，

子类Minerva无法访问到父类的method1方法，故子类不会重写父类的method1函数，

所在地以Minerva().call()将直接调用父类的method1,

如果将父类的method1方法改为public ，则选C。

延伸：

java中public ,protected,private,friendly访问控制权范围：

作用域:      当前类    同一包        子孙类      其他包

public         Y           Y                 Y              Y

private       Y           N                 N             N

protected   Y           Y                 Y              N

firendly       Y           Y                 N             N

动态绑定：

  

运行时绑定也叫动态绑定，它是一种调用对象方法的机制。Java调用对象方法时，一般采用运行时绑定机制。

1．Java的方法调用过程
编译器查看对象的声明类型和方法名（对象变量的声明类型）。通过声明类型找到方法列表。
编译器查看调用方法时提供的参数类型。
如果方法是private、static、final或者构造器，编译器就可以确定调用那个方法。这是静态绑定。
如果不是上述情况，就要使用运行时（动态）绑定。在程序运行时，采用动态绑定意味着：虚拟机将调用对象实际类型所限定的方法。

2．运行时（动态）绑定的过程
虚拟机提取对象的实际类型的方法表；
虚拟机搜索方法签名；
调用方法。
注意，这里说的是对象的实际类型。即在多态的情况下，虚拟机可以找到所运行对象的真正类型

3．在向上转型情况下的动态绑定示例
Java代码
public class Father {  
    public void method() {  
       System.out.println("父类方法，对象类型：" + this.getClass());  
    }  
}  
   
public class Son extends Father {  
    public static void main(String[] args) {  
       Father sample = new Son();//向上转型  
       sample.method();  
    }  
} 


结果1：
父类方法，对象类型：class samples.Son

这个结果没有疑问，声明的是父类的引用（句柄），但准确的调用了子类的对象，调用method，在子类中没有该方法，所以去父类中寻找到并调用 之。
现在修改子类，重写(override)method方法。
Java代码
public class Son extends Father {
    public void method() {
       System.out.println("子类方法，对象类型：" + this.getClass());
    }
  
    public static void main(String[] args) {
       Father sample = new Son();//向上转型
       sample.method();
    }
}
结果2：
子类方法，对象类型：class samples.Son

这个结果也是意料之中的。调用method时，在子类中寻找到了该方法，所以直接调用之。
4.静态绑定成员变量
在处理Java类中的成员变量时，并不是采用运行时绑定，而是一般意义上的静态绑定。所以在向上转型的情况下，对象的方法可以“找到”子类，而对 象的属性还是父类的属性。
现在再进一步变化，在父类和子类中同时定义和赋值同名的成员变量name，并试图输出该变量的值。
Java代码

public class Father {
    protected String name="父亲属性";
  
    public void method() {
       System.out.println("父类方法，对象类型：" + this.getClass());
    }
}

public class Son extends Father {
    protected String name="儿子属性";
  
    public void method() {
       System.out.println("子类方法，对象类型：" + this.getClass());
    }
  
    public static void main(String[] args) {
       Father sample = new Son();//向上转型，new Son() 时候是先构造父类的 
       System.out.println("调用的成员："+sample.name);
    }
}
结果3：
调用的成员：父亲属性

这个结果表明，子类的对象(由父类的引用handle)调用到的是父类的成员变量。所以必须明确，运行时（动态）绑定针对的范畴只是对象的方法。
现在试图调用子类的成员变量name，该怎么做？最简单的办法是将该成员变量封装成方法getter形式。
Java代码


public class Father {
    protected String name = "父亲属性";

    public String getName() {
       return name;
    }

    public void method() {
       System.out.println("父类方法，对象类型：" + this.getClass());
    }
}

public class Son extends Father {
    protected String name="儿子属性";
  
    public String getName() {
       return name;
    }
  
    public void method() {
       System.out.println("子类方法，对象类型：" + this.getClass());
    }
  
    public static void main(String[] args) {
       Father sample = new Son();//向上转型
       System.out.println("调用的成员："+sample.getName());
    }
}
结果4：
调用的成员：儿子属性
总结：属性不能被虚拟调用，因为他不能被重写，而方法可以，它被对象的真实类型调用。

============================================================================

AVA动态绑定的内部实现机制

  JAVA虚拟机调用一个类方法时，它会基于对象引用的类型(通常在编译时可知)来选择所调用的方法。相反，当虚拟机调用一个实例方法时，它会基于对象实际 的类型(只能在运行时得知)来选择所调用的方法，这就是动态绑定，是多态的一种。动态绑定为解决实际的业务问题提供了很大的灵活性，是一种非常优美的机 制。

1 JAVA对象模型

  JAVA虚拟机规范并没有规定JAVA对象在堆里是如何表示的。对象的内部表示也影响着整个堆以及垃圾收集器的设计，它由虚拟机的实现者决定。

  JAVA对象中包含的基本数据由它所属的类及其所有超类声明的实例变量组成。只要有一个对象引用，虚拟机就必须能够快速地定位对象实例的数据。另外，它也 必须能通过该对象引用访问相应的类数据(存储于方法区的类型信息)，因此在对象中通常会有一个指向方法区的指针。当程序在运行时需要转换某个对象引用为另 外一种类型时，虚拟机必须要检查这种转换是否被允许，被转换的对象是否的确是被引用的对象或者它的超类型。当程序在执行instanceof操作时，虚拟 机也进行了同样的检查。所以虚拟机都需要查看被引用的对象的类数据。

  不管虚拟机的实现使用什么样的对象表示法，很可能每个对象都有一个方法表因为方法表加快了调用实例方法时的效率。但是JAVA虚拟机规范并未要求必须使用方法表，所以并不是所有实现中都会使用它。

  下面是一种JAVA对象的内存表示：

 

JAVA对象内存模型

  方法数据存放在类的方法区中，包含一个方法的具体实现的字节码二进制。方法指针直接指向这个方法在内存中的起始位置，通过方法指针就可以找到这个方法。

2 动态绑定内部机制

  方法表是一个指向方法区中的方法指针的数组。方法表中不包含static、private等静态绑定的方法，仅仅包含那些需要动态绑定的实例方法。

  在方法表中，来自超类的方法出现在来自子类的方法之前，并且排列方法指针的顺序和方法在class文件中出现的顺序相同，这种排列顺序的例外情况是，被子类的方法覆盖的方法出现在超类中该方法第一次出现的地方。

  例如有超类Base和子类Derive：

view plain copy to clipboard print ?

public class Base { public Base() { } public void test() { System.out.println( "int Base" ); } public void print() { } } public class Derive extends Base { public Derive() { } public void test() { System.out.println( "int Derive" ); } public void sayHello() { } public static void main( String[] args ) { Base base = new Derive(); base.test(); } }

 

 上例中的Base和Derive的方法表如下：

 

  在这个例子里，test()方法在Base和Derive的方法表中都是同一个位置-位置1。在Base方法表中，test()指针是Base的test()方法内存地址；而在Derive方法表中，方法表的位置1放置的是Derive的test()方法内存地址。

  当JAVA虚拟机执行base.test()时，通过base引用可以找到base所指向的实际对象的内存位置，现在虚拟机不知道base引用的实际对象 是Base还是Derive。但是根据上面的对象内存模型，虚拟机从对象内存中的第一个指针“特殊结构指针”开始，可以找到实际对象的类型数据和 Class实例，这样虚拟机就可以知道base引用的实际对象是Derive对。为了执行test()，虚拟机需要找到test()的字节码，方法的字节 码存放在方法区中。虚拟机从对象内存中的第一个指针“特殊结构指针”开始，搜寻方法表的位置1，位置1指向的test()方法是Derive类的 test()方法，这就是JAVA虚拟机将要执行的test()的字节码。现在，虚拟机知道了调用的实际对象是Derive对象，调用的实际test() 方法是Derive类的test()方法，所以JAVA虚拟机能够正确执行-调用base引用的实际对象的方法而不是base引用本身的方法。

  这是动态绑定的一种实现方式，根据不同的JAVA虚拟机平台和不同的实际约束，动态绑定可以有不同的内部实现机制。