Java静态绑定与动态绑定 - 星夜雨年
- 博客频道 - CSDN.NET
1387人阅读
程序绑定的概念：
绑定指的是一个方法的调用与方法所在的类(方法主体)关联起来。对java来说，绑定分为静态绑定和动态绑定；或者叫做前期绑定和后期绑定.
静态绑定：
在程序执行前方法已经被绑定（也就是说在编译过程中就已经知道这个方法到底是哪个类中的方法），此时由编译器或其它连接程序实现。例如：C。
针对java简单的可以理解为程序编译期的绑定；这里特别说明一点，java当中的方法只有final，static，private和构造方法是前期绑定
动态绑定：
后期绑定：在运行时根据具体对象的类型进行绑定。
若一种语言实现了后期绑定，同时必须提供一些机制，可在运行期间判断对象的类型，并分别调用适当的方法。也就是说，编译器此时依然不知道对象的类型，但方法调用机制能自己去调查，找到正确的方法主体。不同的语言对后期绑定的实现方法是有所区别的。但我们至少可以这样认为：它们都要在对象中安插某些特殊类型的信息。
动态绑定的过程：
虚拟机提取对象的实际类型的方法表；虚拟机搜索方法签名；调用方法。
关于final，static，private和构造方法是前期绑定的理解
对于private的方法，首先一点它不能被继承，既然不能被继承那么就没办法通过它子类的对象来调用，而只能通过这个类自身的对象来调用。因此就可以说private方法和定义这个方法的类绑定在了一起。
final方法虽然可以被继承，但不能被重写（覆盖），虽然子类对象可以调用，但是调用的都是父类中所定义的那个final方法，（由此我们可以知道将方法声明为final类型，一是为了防止方法被覆盖，二是为了有效地关闭java中的动态绑定)。
构造方法也是不能被继承的（网上也有说子类无条件地继承父类的无参数构造函数作为自己的构造函数，不过个人认为这个说法不太恰当，因为我们知道子类是通过super()来调用父类的无参构造方法，来完成对父类的初始化, 而我们使用从父类继承过来的方法是不用这样做的，因此不应该说子类继承了父类的构造方法），因此编译时也可以知道这个构造方法到底是属于哪个类。
对于static方法，具体的原理我也说不太清。不过根据网上的资料和我自己做的实验可以得出结论：static方法可以被子类继承，但是不能被子类重写（覆盖），但是可以被子类隐藏。（这里意思是说如果父类里有一个static方法，它的子类里如果没有对应的方法，那么当子类对象调用这个方法时就会使用父类中的方法。而如果子类中定义了相同的方法，则会调用子类的中定义的方法。唯一的不同就是，当子类对象上转型为父类对象时，不论子类中有没有定义这个静态方法，该对象都会使用父类中的静态方法。因此这里说静态方法可以被隐藏而不能被覆盖。这与子类隐藏父类中的成员变量是一样的。隐藏和覆盖的区别在于，子类对象转换成父类对象后，能够访问父类被隐藏的变量和方法，而不能访问父类被覆盖的方法）
由上面我们可以得出结论，如果一个方法不可被继承或者继承后不可被覆盖，那么这个方法就采用的静态绑定。
java的编译与运行
java的编译过程是将java源文件编译成字节码（jvm可执行代码，即.class文件）的过程，在这个过程中java是不与内存打交道的，在这个过程中编译器会进行语法的分析，如果语法不正确就会报错。
Java的运行过程是指jvm（java虚拟机）装载字节码文件并解释执行。在这个过程才是真正的创立内存布局，执行java程序。
java字节码的执行有两种方式： （1）即时编译方式：解释器先将字节编译成机器码，然后再执行该机器码；（2）解释执行方式：解释器通过每次解释并执行一小段代码来完成java字节码程序的所有操作。（这里我们可以看出java程序在执行过程中其实是进行了两次转换，先转成字节码再转换成机器码。这也正是java能一次编译，到处运行的原因。在不同的平台上装上对应的java虚拟机，就可以实现相同的字节码转换成不同平台上的机器码，从而在不同的平台上运行）
前面已经说了对于java当中的方法而言，除了final，static，private
和构造方法是前期绑定外，其他的方法全部为动态绑定。
而动态绑定的典型发生在父类和子类的转换声明之下：
比如：Parent p = new Children();
其具体过程细节如下：
1：编译器检查对象的声明类型和方法名。
假设我们调用x.f(args)方法，并且x已经被声明为C类的对象，那么编译器会列举出C 类中所有的名称为f 的方法和从C 类的超类继承过来的f 方法。
2：接下来编译器检查方法调用中提供的参数类型。
如果在所有名称为f 的方法中有一个参数类型和调用提供的参数类型最为匹配，那么就调用这个方法，这个过程叫做“重载解析”。
3：当程序运行并且使用动态绑定调用方法时，虚拟机必须调用同x所指向的对象的实际类型相匹配的方法版本。
假设实际类型为D(C的子类)，如果D类定义了f(String)那么该方法被调用，否则就在D的超类中搜寻方法f(String),依次类推。
JAVA 虚拟机调用一个类方法时（静态方法），它会基于对象引用的类型(通常在编译时可知)来选择所调用的方法。相反，当虚拟机调用一个实例方法时，它会基于对象实际的类型(只能在运行时得知)来选择所调用的方法，这就是动态绑定，是多态的一种。动态绑定为解决实际的业务问题提供了很大的灵活性，是一种非常优美的机制。
与方法不同，在处理java类中的成员变量（实例变量和类变量）时，并不是采用运行时绑定，而是一般意义上的静态绑定。所以在向上转型的情况下，对象的方法可以找到子类，而对象的属性（成员变量）还是父类的属性（子类对父类成员变量的隐藏）。
public class Father {
protected String name = &父亲属性&;
public class Son extends Father {
protected String name = &儿子属性&;
public static void main(String[] args) {
Father sample = new Son();
System.out.println(&调用的属性：& + sample.name);
结论，调用的成员为父亲的属性。
这个结果表明，子类的对象(由父类的引用handle)调用到的是父类的成员变量。所以必须明确，运行时（动态）绑定针对的范畴只是对象的方法。
现在试图调用子类的成员变量name，该怎么做？最简单的办法是将该成员变量封装成方法getter形式。
代码如下：
public class Father {
protected String name = &父亲属性&;
public String getName() {
public class Son extends Father {
protected String name = &儿子属性&;
public String getName() {
public static void main(String[] args) {
Father sample = new Son();
System.out.println(&调用的属性:& + sample.getName());
结果：调用的是儿子的属性
java因为什么对属性要采取静态的绑定方法。这是因为静态绑定是有很多的好处，它可以让我们在编译期就发现程序中的错误，而不是在运行期。这样就可以提高程序的运行效率！而对方法采取动态绑定是为了实现多态，多态是java的一大特色。多态也是面向对象的关键技术之一，所以java是以效率为代价来实现多态这是很值得的。
注：以上内容大部分来自互联网，小部分是个人见解，绝非权威性言论。如有语言表达不当或者表述不正确的地方，万望指教。
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：26883次
排名：千里之外
原创：28篇
(2)(4)(1)(4)(6)(5)(1)(1)(2)(1)(3)(1)java动态绑定在属性和方法上的不同_小组_ThinkSAAS
java动态绑定在属性和方法上的不同
java动态绑定在属性和方法上的不同
运行时绑定也叫动态绑定，它是一种调用对象方法的机制。Java调用对象方法时，一般采用运行时绑定机制。
1．Java的方法调用过程
编译器查看对象的声明类型和方法名（对象变量的声明类型）。通过声明类型找到方法列表。
编译器查看调用方法时提供的参数类型。
如果方法是private、static、final或者构造器，编译器就可以确定调用那个方法。这是静态绑定。
如果不是上述情况，就要使用运行时（动态）绑定。
在程序运行时，采用动态绑定意味着：虚拟机将调用对象实际类型所限定的方法。
2．运行时（动态）绑定的过程
虚拟机提取对象的实际类型的方法表；
虚拟机搜索方法签名；
调用方法。
注意，这里说的是对象的实际类型。即在多态的情况下，虚拟机可以找到所运行对象的真正类型。
3．在向上转型情况下的动态绑定示例
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();
父类方法，对象类型：class samples.Son
这个结果没有疑问，声明的是父类的引用（句柄），但准确的调用了子类的对象，调用method，在子类中没有该方法，所以去父类中寻找到并调用之。
现在修改子类，重写(override)method方法。
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();
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();
子类方法，对象类型：class samples.Son
这个结果也是意料之中的。调用method时，在子类中寻找到了该方法，所以直接调用之。
4.静态绑定成员变量
在处理Java类中的成员变量时，并不是采用运行时绑定，而是一般意义上的静态绑定。所以在向上转型的情况下，对象的方法可以“找到”子类，而对象的属性还是父类的属性。
现在再进一步变化，在父类和子类中同时定义和赋值同名的成员变量name，并试图输出该变量的值。
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);
调用的成员：父亲属性
这个结果表明，子类的对象(由父类的引用handle)调用到的是父类的成员变量。所以必须明确，运行时（动态）绑定针对的范畴只是对象的方法。
现在试图调用子类的成员变量name，该怎么做？最简单的办法是将该成员变量封装成方法getter形式。
public class Father {
protected String name ="父亲属性";
public String getName() {
public void method() {
System.out.println("父类方法，对象类型："+ this.getClass());
public class Son extends Father {
protected String name="儿子属性";
public String getName() {
public void method() {
System.out.println("子类方法，对象类型："+ this.getClass());
public static void main(String[] args) {
Father sample = new Son();//向上转型
System.out.println("调用的成员："+sample.getName());
调用的成员：儿子属性
总结：属性不能被虚拟调用，因为他不能被重写，而方法可以，它被对象的真实类型调用。
用户评论(0)
开发技术学习小组列表
PHP开发框架
缓存Memcache
服务器环境
ThinkSAAS商业授权：
ThinkSAAS为用户提供有偿个性定制开发服务
ThinkSAAS将为商业授权用户提供二次开发指导和技术支持
手机客户端
ThinkSAAS接收任何功能的Iphone(IOS)和Android手机的客户端定制开发服务
让ThinkSAAS更好，把建议拿来。
iphone扫码下载客户端[#0x000C] 有关向下转型的必要性和动态绑定的细节 - #import ~ 青山代码 - ITeye技术网站
博客分类：
　　在[#0x0009]里面说过，“除了static方法和final方法(final包含private)外，Java对其他所有的方法都采用dynamic binding”(P151, Chapter 8, Thinking in Java, Fourth Edition)，不过下面的这个例子也许会让人有点吃惊(adapted from Chapter 8, Thinking in Java, Fourth Edition)：
//@file RTTI.java
//RTTI: Run-Time Type Identification
class Useful
public void f() {System.out.println("Useful.f()");}
class MoreUseful extends Useful
public void f() {System.out.println("MoreUseful.f()");}
public void g() {System.out.println("MoreUseful.g()");}
public class RTTI
public static void main(String[] args)
Useful x = new MoreUseful();
//x.g();//编译错误：找不到符号
((MoreUseful)x).g(); // Downcast/RTTI
MoreUseful.f()
MoreUseful.g()
　　按理来说，x.f()通过动态绑定能够正确调用MoreUseful的f()方法，那么为什么x.g()就不行呢？真的是“除了static方法和final方法(final包含private)外，Java对其他‘所有’的方法都采用dynamic binding”吗？还是只对覆写方法才动态绑定？
　　其实这里涉及到动态绑定的细节问题。当然，的确是“除了static方法和final方法(final包含private)外，Java对其他所有的方法都采用dynamic binding”，只不过在使用动态绑定之前，编译器还做了一些其他的工作，而这些工作，就是造成上面代码结果的原因。
　　Java的方法调用过程：
　　-&编译器查看引用(x)的声明类型(Useful)和方法名(g())；
　　　　--&通过声明类型找到方法列表；
　　　　　　----&如果方法名不在方法列表中，则编译器报错(g()不在Useful的方法列表里，所以出错)；
　　　　　　----&如果方法名在方法列表中，则继续下列步骤；
　　-&编译器查看方法的参数列表，获取参数方法签名；
　　　　--&如果方法是private、static、final或者构造器，编译器就可以确定调用那个方法(这是静态绑定)；
　　　　--&如果不是上述情况，就要使用动态绑定；
　　可见，x.g()出错是由于使用动态绑定前的方法名检查未通过。从这个角度来说，动态绑定似乎的确只适用于覆写方法。
　　由于无法使用动态绑定，所以要正确调用x.g()方法，向下转型((MoreUseful)x)就必不可少了。这里x必须指向一个实际的MoreUseful对象(即是通过向上转型得来)，如果Useful x = new Useful()，那么((MoreUseful)x)会编译报错。
浏览: 79861 次
来自: 武汉
写的很好，真的很好。
[client]default-character-set=u ...
你好，请问Could not resolve placehol ...
[mysql]default-character-set=ut ...
基本思想就是在run()方法中的while (true)里检查 ...【解惑】Java动态绑定机制的内幕 - 爪哇人 - ITeye技术网站
博客分类：
在Java方法调用的过程中，JVM是如何知道调用的是哪个类的方法源代码？ 这里面到底有什么内幕呢？ 这篇文章我们就将揭露JVM方法调用的静态(static binding)
和动态绑定机制(auto binding)
★ 静态绑定机制
//被调用的类
package hr.
class Father{
public static void f1(){
System.out.println("Father— f1()");
//调用静态方法
import hr.test.F
public class StaticCall{
public static void main(){
Father.f1(); //调用静态方法
上面的源代码中执行方法调用的语句(Father.f1())被编译器编译成了一条指令：invokestatic #13。我们看看JVM是如何处理这条指令的
(1) 指令中的#13指的是StaticCall类的常量池中第13个常量表的索引项(关于常量池详见《
》)。这个常量表(CONSTATN_Methodref_info
记录的是方法f1信息的符号引用(包括f1所在的类名，方法名和返回类型)。JVM会首先根据这个符号引用找到方法f1所在的类的全限定名: hr.test.Father。
(2) 紧接着JVM会加载、链接和初始化Father类。
(3) 然后在Father类所在的方法区中找到f1()方法的直接地址，并将这个直接地址记录到StaticCall类的常量池索引为13的常量表中。这个过程叫常量池解析
，以后再次调用Father.f1()时，将直接找到f1方法的字节码。
(4) 完成了StaticCall类常量池索引项13的常量表的解析之后，JVM就可以调用f1()方法，并开始解释执行f1()方法中的指令了。
通过上面的过程，我们发现经过常量池解析之后，JVM就能够确定要调用的f1()方法具体在内存的什么位置上了。实际上，这个信息在编译阶段就已经在StaticCall类的常量池中记录了下来。这种在编译阶段就能够确定调用哪个方法的方式，我们叫做
静态绑定机制
除了被static
修饰的静态方法，所有被private
修饰的私有方法、被final
修饰的禁止子类覆盖的方法都会被编译成invokestatic指令。另外所有类的初始化方法&init&和&clinit&会被编译成invokespecial指令。JVM会采用静态绑定机制来顺利的调用这些方法。
★ 动态绑定机制
package hr.
//被调用的父类
class Father{
public void f1(){
System.out.println("father-f1()");
public void f1(int i){
System.out.println("father-f1()
para-int "+i);
//被调用的子类
class Son extends Father{
public void f1(){ //覆盖父类的方法
System.out.println("Son-f1()");
public void f1(char c){
System.out.println("Son-s1() para-char "+c);
//调用方法
import hr.test.*;
public class AutoCall{
public static void main(String[] args){
Father father=new Son(); //多态
father.f1(); //打印结果： Son-f1()
上面的源代码中有三个重要的概念：多态(polymorphism)
、方法覆盖
、方法重载
。打印的结果大家也都比较清楚，但是JVM是如何知道f.f1()调用的是子类Sun中方法而不是Father中的方法呢？在解释这个问题之前，我们首先简单的讲下JVM管理的一个非常重要的数据结构——方法表
在JVM加载类的同时，会在方法区中为这个类存放很多信息(详见《
》)。其中就有一个数据结构叫方法表。它以数组的形式记录了当前类及其所有超类的可见方法字节码在内存中的直接地址
。下图是上面源代码中Father和Sun类在方法区中的方法表：
上图中的方法表有两个特点：(1) 子类方法表中继承了父类的方法，比如Father extends Object。 (2) 相同的方法(相同的方法签名：方法名和参数列表)在所有类的方法表中的索引相同。比如Father方法表中的f1()和Son方法表中的f1()都位于各自方法表的第11项中。
对于上面的源代码，编译器首先会把main方法编译成下面的字节码指令：
new hr.test.Son [13] //在堆中开辟一个Son对象的内存空间，并将对象引用压入操作数栈
invokespecial #7 [15] // 调用初始化方法来初始化堆中的Son对象
astore_1 //弹出操作数栈的Son对象引用压入局部变量1中
aload_1 //取出局部变量1中的对象引用压入操作数栈
invokevirtual #15 //调用f1()方法
其中invokevirtual指令的详细调用过程是这样的：
(1) invokevirtual指令中的#15指的是AutoCall类的常量池中第15个常量表的索引项。这个常量表(CONSTATN_Methodref_info
记录的是方法f1信息的符号引用(包括f1所在的类名，方法名和返回类型)。JVM会首先根据这个符号引用找到调用方法f1的类的全限定名:
hr.test.Father。这是因为调用方法f1的类的对象father声明为Father类型。
(2) 在Father类型的方法表中查找方法f1，如果找到，则将方法f1在方法表中的索引项11(如上图)记录到AutoCall类的常量池中第15个常量表中(常量池解析
)。这里有一点要注意：如果Father类型方法表中没有方法f1，那么即使Son类型中方法表有，编译的时候也通过不了。因为调用方法f1的类的对象father的声明为Father类型。
(3) 在调用invokevirtual指令前有一个aload_1指令，它会将开始创建在堆中的Son对象的引用压入操作数栈。然后invokevirtual指令会根据这个Son对象的引用首先找到堆中的Son对象，然后进一步找到Son对象所属类型的方法表。过程如下图所示：
(4) 这是通过第(2)步中解析完成的#15常量表中的方法表的索引项11，可以定位到Son类型方法表中的方法f1()，然后通过直接地址找到该方法字节码所在的内存空间。
很明显，根据对象(father)的声明类型(Father)还不能够确定调用方法f1的位置，必须根据father在堆中实际创建的对象类型Son来确定f1方法所在的位置。这种在程序运行过程中，通过动态创建的对象的方法表来定位方法的方式，我们叫做
动态绑定机制
上面的过程很清楚的反映出在方法覆盖的多态调用的情况下，JVM是如何定位到准确的方法的。但是下面的调用方法JVM是如何定位的呢？(仍然使用上面代码中的Father和Son类型)
public class AutoCall{
public static void main(String[] args){
Father father=new Son();
char c='a';
father.f1(c); //打印结果：father-f1()
para-int 97
问题是Fahter类型中并没有方法签名为f1(char)的方法呀。但打印结果显示JVM调用了Father类型中的f1(int)方法，并没有调用到Son类型中的f1(char)方法。
根据上面详细阐述的调用过程，首先可以明确的是：JVM首先是根据对象father声明的类型Father来解析常量池的(也就是用Father方法表中的索引项来代替常量池中的符号引用)。如果Father中没有匹配到"合适"
的方法，就无法进行常量池解析，这在编译阶段就通过不了。
那么什么叫"合适"的方法呢？当然，方法签名完全一样的方法自然是合适的。但是如果方法中的参数类型在声明的类型中并不能找到呢？比如上面的代码中调用father.f1(char)，Father类型并没有f1(char)的方法签名。实际上，JVM会找到一种“凑合”的办法，就是通过
参数的自动转型
到“合适”的 方法。比如char可以通过自动转型成int，那么Father类中就可以匹配到这个方法了
(关于Java的自动转型问题可以参见《
》)。但是还有一个问题，如果通过自动转型发现可以“凑合”出两个方法的话怎么办？比如下面的代码：
class Father{
public void f1(Object o){
System.out.println("Object");
public void f1(double[] d){
System.out.println("double[]");
public class Demo{
public static void main(String[] args) {
new Father().f1(null); //打印结果： double[]
null可以引用于任何的引用类型，那么JVM如何确定“合适”的方法呢。一个很重要的标准就是：如果一个方法可以接受传递给另一个方法的任何参数，那么第一个方法就相对不合适。比如上面的代码: 任何传递给f1(double[])方法的参数都可以传递给f1(Object)方法，而反之却不行，那么f1(double[])方法就更合适。因此JVM就会调用这个更合适的方法。
(1) 所有私有方法、静态方法、构造器及初始化方法&clinit&都是采用静态绑定机制。在编译器阶段就已经指明了调用方法在常量池中的符号引用，JVM运行的时候只需要进行一次常量池解析即可。
(2) 类对象方法的调用必须在运行过程中采用动态绑定机制。
首先，根据对象的声明类型(对象引用的类型)找到“合适”的方法。具体步骤如下：
① 如果能在声明类型中匹配到方法签名完全一样(参数类型一致)的方法，那么这个方法是最合适的。
② 在第①条不能满足的情况下，寻找可以“凑合”的方法。标准就是通过将参数类型进行自动转型之后再进行匹配。如果匹配到多个自动转型后的方法签名f(A)和f(B)，则用下面的标准来确定合适的方法：传递给f(A)方法的参数都可以传递给f(B)，则f(A)最合适。反之f(B)最合适
③ 如果仍然在声明类型中找不到“合适”的方法，则编译阶段就无法通过。
然后，根据在堆中创建对象的实际类型找到对应的方法表，从中确定具体的方法在内存中的位置。
★ 覆写（override）
一个实例方法可以覆写（override）在其超类中可访问到的具有相同签名的所有实例方法，从而使能了动态分派（dynamic dispatch）；换句话说，VM将基于实例的运行期类型来选择要调用的覆写方法。覆写是面向对象编程技术的基础，并且是唯一没有被普遍劝阻的名字重用形式：
class Base{
public void f(){}
class Derived extends Base{
public void f(){}
★ 隐藏（hide）
一个域、静态方法或成员类型可以分别隐藏（hide）在其超类中可访问到的具有相同名字（对方法而言就是相同的方法签名)的所有域、静态方法或成员类型。隐藏一个成员将阻止其被继承。
class Base{
public static void f(){}
class Derived extends Base
private static void f(){}
//hides Base. f()
★ 重载（overload）
在某个类中的方法可以重载（overload）另一个方法，只要它们具有相同的名字和不同的签名。由调用所指定的重载方法是在编译期选定的。
class CircuitBreaker{
public void f (int i){}
//int overloading
public void f(String s){}
//String overloading
★ 遮蔽（shadow）
一个变量、方法或类型可以分别遮蔽（shadow）在一个闭合的文本范围内的具有相同名字的所有变量、方法或类型。如果一个实体被遮蔽了，那么你用它的简单名是无法引用到它的;根据实体的不同，有时你根本就无法引用到它。
class WhoKnows{
static String sentence=”I don't know.”;
public static void main(String[] args〕{
String sentence=”I don't know.”;
//shadows static field
System.out. println (sentence);
// prints local variable
尽管遮蔽通常是被劝阻的，但是有一种通用的惯用法确实涉及遮蔽。构造器经常将来自其所在类的某个域名重用为一个参数，以传递这个命名域的值。这种惯用法并不是没有风险，但是大多数Java程序员都认为这种风格带来的实惠要超过
class Belt{
//Parameter shadows Belt. size
public Belt (int size){
this. size=
★ 遮掩（obscure）
一个变量可以遮掩具有相同名字的一个类型，只要它们都在同一个范围内:如果这个名字被用于变量与类型都被许可的范围，那么它将引用到变量上。相似地，一个变量或一个类型可以遮掩一个包。遮掩是唯一一种两个名字位于不同的名字空间的名字重用形式，这些名字空间包括:变量、包、方法或类型。如果一个类型或一个包被遮掩了，那么你不能通过其简单
名引用到它，除非是在这样一个上下文环境中，即语法只允许在其名字空间中出现一种名字。遵守命名习惯就可以极大地消除产生遮掩的可能性:
public class Obscure{
static String S// Obscures type java.lang.System
public static void main(String[] args)
// Next line won't compile:System refers to static field
System. out. println(“hello, obscure world!”);
论坛回复 /
(0 / 1636)
文章很不错，从字节码和jvm的角度说明静态和动态调用。这个地方引用除了被static 修饰的静态方法，所有被private 修饰的私有方法、被final 修饰的禁止子类覆盖的方法都会被编译成invokestatic指令。另外所有类的初始化方法&init&和&clinit&会被编译成invokespecial指令。JVM会采用静态绑定机制来顺利的调用这些方法。应该是private修饰的私有方法会被编译为invokespecial指令。还有一个地方引用★ 隐藏（hide）&&&&&& 一个域、静态方法或成员类型可以分别隐藏（hide）在其超类中可访问到的具有相同名字（对方法而言就是相同的方法签名)的所有域、静态方法或成员类型。隐藏一个成员将阻止其被继承。不可以隐藏，因为子类如果和父类有相同的方法签名，并且可以被重写，子类方法的域（即修饰符）应该不低于父类的修饰符级别。
除了被static 修饰的静态方法，所有被private 修饰的私有方法、被final 修饰的禁止子类覆盖的方法都会被编译成invokestatic指令。另外所有类的初始化方法&init&和&clinit&会被编译成invokespecial指令。JVM会采用静态绑定机制来顺利的调用这些方法。应该是private修饰的私有方法会被编译为invokespecial指令。
Heart.X.Raid
浏览: 427091 次
来自: 武汉
java.io.FileNotFoundException:
java.io.FileNotFoundException:
楼主这个很不错啊
可惜包里是class文件
能不能发源码学 ...
为博主点赞
我也是ccnu的， 包里是.class文件，博主给将源码传至g ...}