如果你用過反射并且執行過getDeclaredMethods方法的話，你可能會感到很吃驚，你會發現出現了很多源代碼里沒有的方法，如果你看一下這些方法的修飾符的話，可能會發現里面有些方法是volatile的，順便說一句，如果在Java面試里問到“什么是volatile方法？”，你可能會嚇出一身冷汗，正確的答案是沒有volatile方法，但同時，getDeclaredMethods()或者getMethods()回傳的這些方法，Modifier.isVolatile(method.getModifiers())的結果卻是true，
一些用戶遇到過這樣的問題，他們發現，使用immutator（這個專案探索了Java的一些不為人知的細節）生成的Java代碼使用volatile了作為方法的關鍵字，而這樣的代碼沒法通過編譯，結果就是這根本沒法用，
這是怎么回事？syntethic和bridge方法又是什么？
可見性
當你創建一個嵌套類的時候，它的私有變數和方法對上層的類是可見的，這個在不可變嵌套式Builder模式中用到了，這是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對所有的類都一視同仁，它都認為是頂級類，所有類都會被編譯成頂級類，而那些內部類編譯完后會生成…$… class的類檔案，
$ ls -Fart
../ SyntheticMethodTest2$A.class MyClass.java SyntheticMethodTest4.java SyntheticMethodTest2.java
SyntheticMethodTest2.class SyntheticMethodTest3.java ./ MyClassSon.java SyntheticMethodTest1.java
如果你創建一個內部類的話，它會被徹底編譯成一個頂級類，
那這些私有變數又是如何被外部類訪問的呢？如果它們是個頂級類的私有變數（它們的確也是），那為什么別的類還能直接訪問這些變數？
javac是這樣解決這個問題的，對于任何private的欄位，方法或者建構式，如果它們也被其它頂層類所使用，就會生成一個synthetic方法，這些synthetic方法是用來訪問最初的私有變數/方法/建構式的，這些方法的生成也很智能：只有確實被外部類用到了，才會生成這樣的方法，
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方法，這些方法并不存在于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 {
@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 {
@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方法的話，說不定面試官知道的還沒你多:-) 私信”學習“有驚喜
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/71637.html
標籤：Java
上一篇：MySQL_JDBC