昨天有一個比較愛思考的同僚和我提起一個問題：為什麼匿名内部類使用的局部變量和參數需要final修飾，而外部類的成員變量則不用？對這個問題我一直作為預設的文法了，木有仔細想過為什麼（在分析完後有點印象在哪本書上看到過，但是就是沒有找到，難道是我的幻覺？呵呵）。雖然沒有想過，但是還是借着之前研究過位元組碼的基礎上，分析了一些，感覺上是找到了一些答案，分享一下；也希望有大牛給指出一些不足的地方。
假如我們有以下的代碼：
1 interface printer {
2 public void print();
3 }
4
5 class myapplication {
6 private int field = 10;
7
8 public void print(final integer param) {
9 final long local = 100;
10 final long local2 = param.longvalue() + 100;
11 printer printer = new printer() {
12 @override
13 public void print() {
14 system.out.println("local value: " + local);
15 system.out.println("local2 value: " + local2);
16 system.out.println("parameter: " + param);
17 system.out.println("field value: " + field);
18 }
19 };
20 printer.print();
21 }
22 }
這裡因為param要在匿名内部類的print()方法中使用，因而它要用final修飾；local/local2是局部變量，因而也需要final修飾；而field是外部類myapplication的字段，因而不需要final修飾。這種設計是基于什麼理由呢？
我想這個問題應該從java是如何實作匿名内部類的。其中有兩點：
1. 匿名内部類可以使用外部類的變量（局部或成員變來那個）
2. 匿名内部類中不同的方法可以共享這些變量
根據這兩點資訊我們就可以分析，可能這些變量會在匿名内部類的字段中儲存着，并且在構造的時候将他們的值/引用傳入内部類。這樣就可以保證同時實作上述兩點了。
事實上，java就是這樣設計的，并且所謂匿名類，其實并不是匿名的，隻是編譯器幫我們命名了而已。這點我們可以通過這兩個類編譯出來的位元組碼看出來：
1 // compiled from printer.java (version 1.6 : 50.0, super bit)
2 class levin.test.anonymous.myapplication$1 implements levin.test.anonymous.printer {
3
4 // field descriptor #8 llevin/test/anonymous/myapplication;
5 final synthetic levin.test.anonymous.myapplication this$0;
6
7 // field descriptor #10 j
8 private final synthetic long val$local2;
9
10 // field descriptor #12 ljava/lang/integer;
11 private final synthetic java.lang.integer val$param;
12
13 // method descriptor #14 (llevin/test/anonymous/myapplication;jljava/lang/integer;)v
14 // stack: 3, locals: 5
15 myapplication$1(levin.test.anonymous.myapplication arg0, long arg1, java.lang.integer arg2);
16 0 aload_0 [this]
17 1 aload_1 [arg0]
18 2 putfield levin.test.anonymous.myapplication$1.this$0 : levin.test.anonymous.myapplication [16]
19 5 aload_0 [this]
20 6 lload_2 [arg1]
21 7 putfield levin.test.anonymous.myapplication$1.val$local2 : long [18]
22 10 aload_0 [this]
23 11 aload 4 [arg2]
24 13 putfield levin.test.anonymous.myapplication$1.val$param : java.lang.integer [20]
25 16 aload_0 [this]
26 17 invokespecial java.lang.object() [22]
27 20 return
28 line numbers:
29 [pc: 0, line: 1]
30 [pc: 16, line: 13]
31 local variable table:
32 [pc: 0, pc: 21] local: this index: 0 type: new levin.test.anonymous.myapplication(){}
33
34 // method descriptor #24 ()v
35 // stack: 4, locals: 1
36 public void print();
37 0 getstatic java.lang.system.out : java.io.printstream [30]
38 3 ldc <string "local value: 100"> [36]
39 5 invokevirtual java.io.printstream.println(java.lang.string) : void [38]
40 8 getstatic java.lang.system.out : java.io.printstream [30]
41 11 new java.lang.stringbuilder [44]
42 14 dup
43 15 ldc <string "local2 value: "> [46]
44 17 invokespecial java.lang.stringbuilder(java.lang.string) [48]
45 20 aload_0 [this]
46 21 getfield levin.test.anonymous.myapplication$1.val$local2 : long [18]
47 24 invokevirtual java.lang.stringbuilder.append(long) : java.lang.stringbuilder [50]
48 27 invokevirtual java.lang.stringbuilder.tostring() : java.lang.string [54]
49 30 invokevirtual java.io.printstream.println(java.lang.string) : void [38]
50 33 getstatic java.lang.system.out : java.io.printstream [30]
51 36 new java.lang.stringbuilder [44]
52 39 dup
53 40 ldc <string "parameter: "> [58]
54 42 invokespecial java.lang.stringbuilder(java.lang.string) [48]
55 45 aload_0 [this]
56 46 getfield levin.test.anonymous.myapplication$1.val$param : java.lang.integer [20]
57 49 invokevirtual java.lang.stringbuilder.append(java.lang.object) : java.lang.stringbuilder [60]
58 52 invokevirtual java.lang.stringbuilder.tostring() : java.lang.string [54]
59 55 invokevirtual java.io.printstream.println(java.lang.string) : void [38]
60 58 getstatic java.lang.system.out : java.io.printstream [30]
61 61 new java.lang.stringbuilder [44]
62 64 dup
63 65 ldc <string "field value: "> [63]
64 67 invokespecial java.lang.stringbuilder(java.lang.string) [48]
65 70 aload_0 [this]
66 71 getfield levin.test.anonymous.myapplication$1.this$0 : levin.test.anonymous.myapplication [16]
67 74 invokestatic levin.test.anonymous.myapplication.access$0(levin.test.anonymous.myapplication) : int [65]
68 77 invokevirtual java.lang.stringbuilder.append(int) : java.lang.stringbuilder [71]
69 80 invokevirtual java.lang.stringbuilder.tostring() : java.lang.string [54]
70 83 invokevirtual java.io.printstream.println(java.lang.string) : void [38]
71 86 return
72 line numbers:
73 [pc: 0, line: 16]
74 [pc: 8, line: 17]
75 [pc: 33, line: 18]
76 [pc: 58, line: 19]
77 [pc: 86, line: 20]
78 local variable table:
79 [pc: 0, pc: 87] local: this index: 0 type: new levin.test.anonymous.myapplication(){}
80
81 inner classes:
82 [inner class info: #1 levin/test/anonymous/myapplication$1, outer class info: #0
83 inner name: #0, accessflags: 0 default]
84 enclosing method: #66 #77 levin/test/anonymous/myapplication.print(ljava/lang/integer;)v
85 }
2 class levin.test.anonymous.myapplication {
4 // field descriptor #6 i
5 private int field;
7 // method descriptor #8 ()v
8 // stack: 2, locals: 1
9 myapplication();
10 0 aload_0 [this]
11 1 invokespecial java.lang.object() [10]
12 4 aload_0 [this]
13 5 bipush 10
14 7 putfield levin.test.anonymous.myapplication.field : int [12]
15 10 return
16 line numbers:
17 [pc: 0, line: 7]
18 [pc: 4, line: 8]
19 [pc: 10, line: 7]
20 local variable table:
21 [pc: 0, pc: 11] local: this index: 0 type: levin.test.anonymous.myapplication
22
23 // method descriptor #19 (ljava/lang/integer;)v
24 // stack: 6, locals: 7
25 public void print(java.lang.integer param);
26 0 ldc2_w <long 100> [20]
27 3 lstore_2 [local]
28 4 aload_1 [param]
29 5 invokevirtual java.lang.integer.longvalue() : long [22]
30 8 ldc2_w <long 100> [20]
31 11 ladd
32 12 lstore 4 [local2]
33 14 new levin.test.anonymous.myapplication$1 [28]
34 17 dup
35 18 aload_0 [this]
36 19 lload 4 [local2]
37 21 aload_1 [param]
38 22 invokespecial levin.test.anonymous.myapplication$1(levin.test.anonymous.myapplication, long, java.lang.integer) [30]
39 25 astore 6 [printer]
40 27 aload 6 [printer]
41 29 invokeinterface levin.test.anonymous.printer.print() : void [33] [nargs: 1]
42 34 return
43 line numbers:
44 [pc: 0, line: 11]
45 [pc: 4, line: 12]
46 [pc: 14, line: 13]
47 [pc: 27, line: 22]
48 [pc: 34, line: 23]
49 local variable table:
50 [pc: 0, pc: 35] local: this index: 0 type: levin.test.anonymous.myapplication
51 [pc: 0, pc: 35] local: param index: 1 type: java.lang.integer
52 [pc: 4, pc: 35] local: local index: 2 type: long
53 [pc: 14, pc: 35] local: local2 index: 4 type: long
54 [pc: 27, pc: 35] local: printer index: 6 type: levin.test.anonymous.printer
55
56 // method descriptor #45 (llevin/test/anonymous/myapplication;)i
57 // stack: 1, locals: 1
58 static synthetic int access$0(levin.test.anonymous.myapplication arg0);
59 0 aload_0 [arg0]
60 1 getfield levin.test.anonymous.myapplication.field : int [12]
61 4 ireturn
62 line numbers:
63 [pc: 0, line: 8]
64
65 inner classes:
66 [inner class info: #28 levin/test/anonymous/myapplication$1, outer class info: #0
67 inner name: #0, accessflags: 0 default]
68 }
從這兩段位元組碼中可以看出，編譯器為我們的匿名類起了一個叫myapplication$1的名字，它包含了三個final字段（這裡synthetic修飾符是指這些字段是由編譯器生成的，它們并不存在于源代碼中）：
myapplication的應用this$0
long值val$local2
integer引用val$param
這些字段在構造函數中指派，而構造函數則是在myapplication.print()方法中調用。
由此，我們可以得出一個結論：java對匿名内部類的實作是通過編譯器來支援的，即通過編譯器幫我們産生一個匿名類的類名，将所有在匿名類中用到的局部變量和參數做為内部類的final字段，同是内部類還會引用外部類的執行個體。其實這裡少了local的變量，這是因為local是編譯器常量，編譯器對它做了替換的優化。
其實java中很多文法都是通過編譯器來支援的，而在虛拟機/位元組碼上并沒有什麼差別，比如這裡的final關鍵字，其實細心的人會發現在位元組碼中，param參數并沒有final修飾，而final本身的很多實作就是由編譯器支援的。類似的還有java中得泛型和逆變、協變等。這是題外話。
有了這個基礎後，我們就可以來分析為什麼有些要用final修飾，有些卻不用的問題。
首先我們來分析local2變量，在”匿名類”中，它是通過構造函數傳入到”匿名類”字段中的，因為它是基本類型，因而在夠着函數中指派時（撇開對函數參數傳遞不同虛拟機的不同實作而産生的不同效果），它事實上隻是值的拷貝；因而加入我們可以在”匿名類”中得print()方法中對它指派，那麼這個指派對外部類中得local2變量不會有影響，而程式員在讀代碼中，是從上往下讀的，是以很容易誤認為這段代碼指派會對外部類中得local2變量本身産生影響，何況在源碼中他們的名字都是一樣的，是以我認為了避免這種confuse導緻的一些問題，java設計者才設計出了這樣的文法。
對引用類型，其實也是一樣的，因為引用的傳遞事實上也隻是傳遞引用的數值（簡單的可以了解成為位址），因而對param，如果可以在”匿名類”中指派，也不會在外部類的print()後續方法産生影響。雖然這樣，我們還是可以在内部類中改變引用内部的值的，如果引用類型不是隻讀類型的話；在這裡integer是隻讀類型，因而我們沒法這樣做。（如果學過c++的童鞋可以想想常量指針和指針常量的差別）。
現在還剩下最後一個問題：為什麼引用外部類的字段卻是可以不用final修飾的呢？細心的童鞋可能也已經發現答案了，因為内部類儲存了外部類的引用，因而内部類中對任何字段的修改都回真實的反應到外部類執行個體本身上，是以不需要用final來修飾它。
這個問題基本上就分析到這裡了，不知道我有沒有表達清楚了。
加點題外話吧。
首先是，對這裡的位元組碼，其實還有一點可以借鑒的地方，就是内部類在使用外部類的字段時不是直接取值，而是通過編譯器在外部類中生成的靜态的access$0()方法來取值，我的了解，這裡java設計者想盡量避免其他類直接通路一個類的資料成員，同時生成的access$0()方法還可以被其他類所使用，這遵循了面向對象設計中的兩個重要原則：封裝和複用。
另外，對這個問題也讓我意識到了即使是語言文法層面上的設計都是有原因可循的，我們要善于多問一些為什麼，了解這些設計的原因和局限，記得曾聽到過一句話：知道一門技術的局限，我們才能很好的了解這門技術可以用來做什麼。也隻有這樣我們才能不斷的提高自己。在解決了這個問題後，我突然冒出了一句說java這樣設計也是合理的。是啊，文法其實就一幫人建立的一種解決某些問題的方案，當然有合理和不合理之分，我們其實不用對它視若神聖。
之前有進過某著名高校的研究所學生群，即使在那裡，碼農論也是甚嚣塵上，其實碼農不碼農并不是因為程式員這個職位引起的，而是個人引起的，我們要不斷了解代碼内部的本質才能避免一直做碼農的命運那。個人愚見而已，呵呵。
![C經典書籍筆記——C陷阱與缺陷②(文法陷阱之優先級)一、錯誤案列 二、優先級規律[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)