Java那些不為人知的特殊方法
如果你用過反射并且執行過 getDeclaredMethods方法的話，你可能會感到很驚訝。你會發現很多源代碼里沒有的方法。或許你也看過到這些方法的一些修飾符，并且發現里面有的方法是volatile的。順便說一句，Java面試里如果問到“什么是volatile方法？”,你可能會出一身冷汗。正確的答案應該是方法不能是volatile的。同時 getDeclaredMethods或者 getMethods返回的一些方法， Modifier.isVolatile(method.getModifiers())的返回值是true。
immutator項目的一些用戶遇到過這樣的問題。他發現immutator（這個項目探索了Java一些不太為人所知的細節）生成的Java源代碼使用volatile作為方法的關鍵字，這樣的代碼沒法通過編譯。結果就是這項目沒法使用。
這是怎么回事？什么又是syntethic和bridge方法？
可見性
當你創建一個內部的或者說嵌套的時候，這個類的私有變量和方法對上層的類是可見的。這個在<a target=“_blank”>不可變嵌套式Builder模式</a>中用到了。這在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的類文件。
$ ls -Fart ../ SyntheticMethodTest2$A.class MyClass.java SyntheticMethodTest4.java SyntheticMethodTest2.java SyntheticMethodTest2.class SyntheticMethodTest3.java ./ MyClassSon.java SyntheticMethodTest1.java
如果你創建一個內部的類的話，編譯完后它其實就是個完全的頂層的類。
那這些私有變量是如何被外部類訪問的呢？如果它們是個頂層類的私有變量，它們的確也是，那為什么別的類還能直接訪問這些變量？
javac是這樣解決這個問題的，對于那些聲明為private 的字段，方法或者構造函數，如果它們還被外部類所使用，就會生成一個sythetic的方法。這些sythetic方法是用來訪問最終的私有變量/方法/構造函數的。這些方法的生成也很智能，只有那些確實被外部類用到的才會生成這樣的方法。
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());
}
}
}
生成的這些方法的名字都取決于具體的實現，最后叫什么也不好說。我只能說在我運行的這個平臺上，上述程序的輸出是這樣的：
2 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里面定義的常量，可以明白這些十六進制的數字代表的是什么：
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的方法，只需要寫個簡單的程序 就行了：
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)方法。先別討論代碼整潔的問題了。這只是段演示這個主題的示例代碼而已。簡潔的代碼當然也同樣會出現問題，不過越復雜的代碼越難發現問題罷了。
輸出 是這樣的：
00000001 String get 00001041 Object get
我們有兩個get方法。一個是代碼里的這個，另外一個是synthetic和bridge的方法。用javap反編譯后會是這樣的：
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)方法：
List<?> a = new MyLink();
Object z = a.get(0); 它不能調用返回String的方法，因為List里沒這樣的方法。為了解釋的更清楚一點，我們重寫下add方法而不是get方法：
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方法
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行的地方會拋出一個異常：
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方法的話，說不定面試官知道的還沒你多:-)
譯者注：其實作者說到最后 也沒講完到底什么是volatile方法，其實volatile方法如篇首所說，是不存在的，所謂的volatile方法就是指bridge方法。由于在修飾符中volatile和bridge是同一個值，在之前版本的javap中存在一個BUG，一個bridge方法在反編譯后會顯示成volatile，所以存在”volatile方法”的說法。
原創文章轉載請注明出處：deepinmind