疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

Java那些不为人知的特殊方法


 

         如果你用过反射并且执行过 getDeclaredMethods方法的话,你可能会感到很惊讶。你会发现很多源代码里没有的方法。或许你也看过到这些方法的一些修饰符,并且发现里面有的方法是volatile的。顺便说一句,Java面试里如果问到“什么是volatile方法?”,你可能会出一身冷汗。正确的答案应该是方法不能是volatile的。同时 getDeclaredMethods或者 getMethods返回的一些方法, Modifier.isVolatile(method.getModifiers())的返回值是true。
immutator项目的一些用户遇到过这样的问题。他发现immutator(这个项目探索了Java一些不太为人所知的细节)生成的Java源代码使用volatile作为方法的关键字,这样的代码没法通过编译。结果就是这项目没法使用。
这是怎么回事?什么又是syntethic和bridge方法?

          可见性
          当你创建一个内部的或者说嵌套的时候,这个类的私有变量和方法对上层的类是可见的。这个在不可变嵌套式Builder模式中用到了。这在Java语言规范里是定义好的一个行为。

Java代码 
package synthetic; 
  
public class SyntheticMethodTest1 { 
    private A aObj = new A(); 
  
    public class A { 
        private int i; 
    } 
  
    private class B { 
        private int i = aObj.i; 
    } 
  
    public static void main(String[] args) { 
        SyntheticMethodTest1 me = new SyntheticMethodTest1(); 
        me.aObj.i = 1; 
        B bObj = me.new B(); 
        System.out.println(bObj.i); 
    } 


JVM是如何处理这个的?JVM是不知道类是内部的还是说嵌套的。JVM对所有的类对一视同仁,都认为是顶层的。所有的类都会被编译的顶层的类,那些内部类编译完后会生成...$... class的类文件。

Java代码  收藏代码
$ ls -Fart 
../                       SyntheticMethodTest2$A.class  MyClass.java 

SyntheticMethodTest4.java  SyntheticMethodTest2.java 
SyntheticMethodTest2.class  SyntheticMethodTest3.java     ./            MyClassSon.java 

          SyntheticMethodTest1.java 


       如果你创建一个内部的类的话,编译完后它其实就是个完全的顶层的类。
      那这些私有变量是如何被外部类访问的呢?如果它们是个顶层类的私有变量,它们的确也是,那为什么别的类还能直接访问这些变量?
      javac是这样解决这个问题的,对于那些声明为private 的字段,方法或者构造函数,如果它们还被外部类所使用,就会生成一个sythetic的方法。这些sythetic方法是用来访问最终的私有变量/方法/构造函数的。这些方法的生成也很智能,只有那些确实被外部类用到的才会生成这样的方法。

Java代码  
package synthetic; 
  
import java.lang.reflect.Constructor; 
import java.lang.reflect.Method; 
  
public class SyntheticMethodTest2 { 
  
    public static class A { 
        private A(){} 
        private int x; 
        private void x(){}; 
    } 
  
    public static void main(String[] args) { 
        A a = new A(); 
        a.x = 2; 
        a.x(); 
        System.out.println(a.x); 
        for (Method m : A.class.getDeclaredMethods()) { 
            System.out.println(String.format("%08X", m.getModifiers()) + " " +

m.getName()); 
        } 
        System.out.println("--------------------------"); 
        for (Method m : A.class.getMethods()) { 
            System.out.println(String.format("%08X", m.getModifiers()) + " " +

m.getReturnType().getSimpleName() + " " + m.getName()); 
        } 
        System.out.println("--------------------------"); 
        for( Constructor<?> c : A.class.getDeclaredConstructors() ){ 
            System.out.println(String.format("%08X", c.getModifiers()) + " " +

c.getName()); 
        } 
    } 
}  


生成的这些方法的名字都取决于具体的实现,最后叫什么也不好说。我只能说在我运行的这个平台上,上述程序的输出是这样的:
Java代码  收藏代码

00001008 access$1 
00001008 access$2 
00001008 access$3 
00000002 x 
-------------------------- 
00000111 void wait 
00000011 void wait 
00000011 void wait 
00000001 boolean equals 
00000001 String toString 
00000101 int hashCode 
00000111 Class getClass 
00000111 void notify 
00000111 void notifyAll 
-------------------------- 
00000002 synthetic.SyntheticMethodTest2$A 
00001000 synthetic.SyntheticMethodTest2$A  


         在上面这个程序中,我们把值赋给了变量x,然后又调用 了同名的一个方法。这会触发编译器来生成对应的synthetic方法。你会看到它生成了三个方法,应该是x变量的setter和getter方法,以及x()方法的一个synthetic方法。这些synthetic方法并不存在于getMethods方法里返回的列表中,因为这些是synthetic方法,它们是不能直接调用的。从这点来说,它们和私有方法差不多。
         看一下java.lang.reflect.Modifier里面定义的常量,可以明白这些十六进制的数字代表的是什么:
Java代码  收藏代码
00001008 SYNTHETIC|STATIC 
00000002 PRIVATE 
00000111 NATIVE|FINAL|PUBLIC 
00000011 FINAL|PUBLIC 
00000001 PUBLIC 
00001000 SYNTHETIC  


        列表中有两个是构造方法。还有一个私有方法和一个synthetic的。私有的这个是因为我们确实定义了。synthetic的方法出现是因为我们从外部调用了内部的私有成员。这里面还没有出现bridge方法。

泛型和继承


到现在为止看起来还不错。不过我们还没有看到”volatile”的方法。
       看一下java.lang.reflect.Modifier的源码你会发现0x00000040这个常量定义了两次。一次是定义成VOLATILE,还有一次是BRIDGE(后者是包内部私有的,并不对外开放)。 想出现volatile的方法,只需要写个简单的程序 就行了:
Java代码  收藏代码
package synthetic; 
  
import java.lang.reflect.Method; 
import java.util.LinkedList; 
  
public class SyntheticMethodTest3 { 
  
    public static class MyLink extends LinkedList<String> { 
        @Override 
        public String get(int i) { 
            return ""; 
        } 
    } 
  
    public static void main(String[] args) { 
  
        for (Method m : MyLink.class.getDeclaredMethods()) { 
            System.out.println(String.format("%08X", m.getModifiers()) + " " +

m.getReturnType().getSimpleName() + " " + m.getName()); 
        } 
    } 


         我们的这个链表,有一个返回String的get(int)方法。先别讨论代码整洁的问题了。这只是段演示这个主题的示例代码而已。简洁的代码当然也同样会出现问题,不过越复杂的代码越难发现问题罢了。

输出 是这样的:
Java代码  收藏代码
00000001 String get 
00001041 Object get  


我们有两个get方法。一个是代码里的这个,另外一个是synthetic和bridge的方法。用javap反编译后会是这样的:
Java代码  收藏代码
public java.lang.String get(int); 
  Code: 
   Stack=1, Locals=2, Args_size=2 
   0:   ldc     #2; //String 
   2:   areturn 
  LineNumberTable: 
   line 12: 0 
  
public java.lang.Object get(int); 
  Code: 
   Stack=2, Locals=2, Args_size=2 
   0:   aload_0 
   1:   iload_1 
   2:   invokevirtual   #3; //Method get:(I)Ljava/lang/String; 
   5:   areturn 


          有趣的是,两个方法的签名是一模一样的,只有返回类型不同。这个在JVM里面是允许的,不过在Java语言里是不行的。bridge的这个方法别的啥也不干,就只是调用了下原始的那个方法。

        为什么我们需要这个synthetic方法呢?谁来调用它。比如现在有段代码想要调用一个非MyLink类型变量的get(int)方法:
Java代码  收藏代码
List<?> a = new MyLink(); 
        Object z = a.get(0); 

它不能调用返回String的方法,因为List里没这样的方法。为了解释的更清楚一点,我们重写下add方法而不是get方法:
Java代码  收藏代码
package synthetic; 
  
import java.util.LinkedList; 
import java.util.List; 
  
public class SyntheticMethodTest4 { 
  
    public static class MyLink extends LinkedList<String> { 
        @Override 
        public boolean add(String s) { 
            return true; 
        } 
    } 
  
    public static void main(String[] args) { 
        List a = new MyLink(); 
        a.add(""); 
        a.add(13); 
    } 
}  

 

我们会发现 这个bridge方法
Java代码  收藏代码
public boolean add(java.lang.Object); 
  Code: 
   Stack=2, Locals=2, Args_size=2 
   0:   aload_0 
   1:   aload_1 
   2:   checkcast       #2; //class java/lang/String 
   5:   invokevirtual   #3; //Method add:(Ljava/lang/String;)Z 
   8:   ireturn  


          不仅调用 了原始的方法,它还进行了类型检查。这个是在运行时进行检查的,并不是JVM自己来检查。正如你所想,在18行的地方会抛出一个异常:
Java代码  收藏代码
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String 
    at synthetic.SyntheticMethodTest4$MyLink.add(SyntheticMethodTest4.java:1) 
    at synthetic.SyntheticMethodTest4.main(SyntheticMethodTest4.java:18)  

下次如果你在面试中被问到volatile方法的话,说不定面试官知道的还没你多:-)