一些Java中鮮爲人知的特殊方法，學完後面試官可能都沒你知道的多！

若是你用過反射而且執行過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方法的話，說不定面試官知道的還沒你多:-) 私信」學習「有驚喜