JAVA匿名內部類(Anonymous Classes)

1.前言匿名內部類在我們JAVA程式員的日常工作中經常要用到，但是很多時候也只是照本宣科地用，雖然也在用，但往往忽略了以下幾點：為什麼能這麼用？匿名內部類的語法是怎樣的？有哪些限制？因此，最近，我在完成了手頭的開發任務後，查閱了一下JAVA官方文檔，將匿名內部類的使用進行了一下總結，案例也摘自官方 ...

1.前言

匿名內部類在我們JAVA程式員的日常工作中經常要用到，但是很多時候也只是照本宣科地用，雖然也在用，但往往忽略了以下幾點：為什麼能這麼用？匿名內部類的語法是怎樣的？有哪些限制？因此，最近，我在完成了手頭的開發任務後，查閱了一下JAVA官方文檔，將匿名內部類的使用進行了一下總結，案例也摘自官方文檔。感興趣的可以查閱官方文檔（https://docs.oracle.com/javase/tutorial/java/javaOO/anonymousclasses.html）。

2.匿名內部類

匿名內部類可以使你的代碼更加簡潔，你可以在定義一個類的同時對其進行實例化。它與局部類很相似，不同的是它沒有類名，如果某個局部類你只需要用一次，那麼你就可以使用匿名內部類（Anonymous classes enable you to make your code more concise. They enable you to declare and instantiate a class at the same time. They are like local classes except that they do not have a name. Use them if you need to use a local class only once.）

本節包括以下幾個方面：

定義匿名內部類
匿名內部類的語法
訪問作用域的局部變數、定義和訪問匿名內部類成員
匿名內部類實例

2.1 定義匿名內部類

首先看下官方文檔中給的例子：

 1 public class HelloWorldAnonymousClasses {
 2 
 3     /**
 4      * 包含兩個方法的HelloWorld介面
 5      */
 6     interface HelloWorld {
 7         public void greet();
 8         public void greetSomeone(String someone);
 9     }
10 
11     public void sayHello() {
12 
13         // 1、局部類EnglishGreeting實現了HelloWorld介面
14         class EnglishGreeting implements HelloWorld {
15             String name = "world";
16             public void greet() {
17                 greetSomeone("world");
18             }
19             public void greetSomeone(String someone) {
20                 name = someone;
21                 System.out.println("Hello " + name);
22             }
23         }
24 
25         HelloWorld englishGreeting = new EnglishGreeting();
26 
27         // 2、匿名類實現HelloWorld介面
28         HelloWorld frenchGreeting = new HelloWorld() {
29             String name = "tout le monde";
30             public void greet() {
31                 greetSomeone("tout le monde");
32             }
33             public void greetSomeone(String someone) {
34                 name = someone;
35                 System.out.println("Salut " + name);
36             }
37         };
38 
39         // 3、匿名類實現HelloWorld介面
40         HelloWorld spanishGreeting = new HelloWorld() {
41             String name = "mundo";
42             public void greet() {
43                 greetSomeone("mundo");
44             }
45             public void greetSomeone(String someone) {
46                 name = someone;
47                 System.out.println("Hola, " + name);
48             }
49         };
50         
51         englishGreeting.greet();
52         frenchGreeting.greetSomeone("Fred");
53         spanishGreeting.greet();
54     }
55 
56     public static void main(String... args) {
57         HelloWorldAnonymousClasses myApp = new HelloWorldAnonymousClasses();
58         myApp.sayHello();
59     }
60 }

運行結果為：

1 Hello world
2 Salut Fred
3 Hola, mundo

該例中用局部類來初始化變數englishGreeting，用匿類來初始化變數frenchGreeting和spanishGreeting，兩種實現之間有明顯的區別：

1）局部類EnglishGreetin繼承HelloWorld介面，有自己的類名，定義完成之後需要再用new關鍵字實例化才可以使用；

2）frenchGreeting、spanishGreeting在定義的時候就實例化了，定義完了就可以直接使用；

3）匿名類是一個表達式，因此在定義的最後用分號";"結束。

2.2 匿名內部類的語法

如上文所述，匿名類是一個表達式，匿名類的語法就類似於調用一個類的構建函數（new HelloWorld()），除些之外，還包含了一個代碼塊，在代碼塊中完成類的定義，見以下兩個實例：

案例一，實現介面的匿名類：

 1  HelloWorld frenchGreeting = new HelloWorld() {
 2    String name = "tout le monde";
 3    public void greet() {
 4          greetSomeone("tout le monde");
 5    }
 6    public void greetSomeone(String someone) {
 7         name = someone;
 8         System.out.println("Salut " + name);
 9    }
10  };

案例二，匿名子類（繼承父類）：

 1 public class AnimalTest {
 2 
 3     private final String ANIMAL = "動物";
 4 
 5     public void accessTest() {
 6         System.out.println("匿名內部類訪問其外部類方法");
 7     }
 8 
 9     class Animal {
10         private String name;
11 
12         public Animal(String name) {
13             this.name = name;
14         }
15 
16         public void printAnimalName() {
17             System.out.println(bird.name);
18         }
19     }
20 
21     // 鳥類，匿名子類，繼承自Animal類，可以覆寫父類方法
22     Animal bird = new Animal("布穀鳥") {
23 
24         @Override
25         public void printAnimalName() {
26             accessTest();   　　　　　　　　// 訪問外部類成員
27             System.out.println(ANIMAL);  // 訪問外部類final修飾的變數
28             super.printAnimalName();
29         }
30     };
31 
32     public void print() {
33         bird.printAnimalName();
34     }
35 
36     public static void main(String[] args) {
37 
38         AnimalTest animalTest = new AnimalTest();
39         animalTest.print();
40     }
41 }

運行結果：

運行結果：
匿名內部類訪問其外部類方法
動物
布穀鳥

從以上兩個實例中可知，匿名類表達式包含以下內部分：

操作符：new；
一個要實現的介面或要繼承的類，案例一中的匿名類實現了HellowWorld介面，案例二中的匿名內部類繼承了Animal父類；
一對括弧，如果是匿名子類，與實例化普通類的語法類似，如果有構造參數，要帶上構造參數；如果是實現一個介面，只需要一對空括弧即可；
一段被"{}"括起來類聲明主體；
末尾的";"號（因為匿名類的聲明是一個表達式，是語句的一部分，因此要以分號結尾）。

3.訪問作用域內的局部變數、定義和訪問匿名內部類成員

匿名內部類與局部類對作用域內的變數擁有相同的的訪問許可權。

(1)、匿名內部類可以訪問外部內的所有成員；

(2)、匿名內部類不能訪問外部類未加final修飾的變數（註意：JDK1.8即使沒有用final修飾也可以訪問）；

(3)、屬性屏蔽，與內嵌類相同，匿名內部類定義的類型（如變數）會屏蔽其作用域範圍內的其他同名類型（變數）：

案例一，內嵌類的屬性屏蔽：

 1 public class ShadowTest {
 2 
 3     public int x = 0;
 4 
 5     class FirstLevel {
 6 
 7         public int x = 1;
 8 
 9         void methodInFirstLevel(int x) {
10             System.out.println("x = " + x);
11             System.out.println("this.x = " + this.x);
12             System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);
13         }
14     }
15 
16     public static void main(String... args) {
17         ShadowTest st = new ShadowTest();
18         ShadowTest.FirstLevel fl = st.new FirstLevel();
19         fl.methodInFirstLevel(23);
20     }
21 }

輸出結果為：

x = 23
this.x = 1
ShadowTest.this.x = 0

這個實例中有三個變數x：1、ShadowTest類的成員變數；2、內部類FirstLevel的成員變數；3、內部類方法methodInFirstLevel的參數。

methodInFirstLevel的參數x屏蔽了內部類FirstLevel的成員變數，因此，在該方法內部使用x時實際上是使用的是參數x，可以使用this關鍵字來指定引用是成員變數x：

1 System.out.println("this.x = " + this.x);

利用類名來引用其成員變數擁有最高的優先順序，不會被其他同名變數屏蔽，如：

1 System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);

案例二，匿名內部類的屬性屏蔽：

 1 public class ShadowTest {
 2     public int x = 0;
 3 
 4     interface FirstLevel {
 5      void methodInFirstLevel(int x);
 6     }
 7 
 8     FirstLevel firstLevel =  new FirstLevel() {
 9 
10         public int x = 1;
11 
12         @Override
13         public void methodInFirstLevel(int x) {
14             System.out.println("x = " + x);
15             System.out.println("this.x = " + this.x);
16             System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);
17         }
18     };
19 
20     public static void main(String... args) {
21         ShadowTest st = new ShadowTest();
22         ShadowTest.FirstLevel fl = st.firstLevel;
23         fl.methodInFirstLevel(23);
24     }
25 }

輸出結果為：

x = 23
this.x = 1
ShadowTest.this.x = 0

(4)、匿名內部類中不能定義靜態屬性、方法；　　

 1 public class ShadowTest {
 2     public int x = 0;
 3 
 4     interface FirstLevel {
 5      void methodInFirstLevel(int x);
 6     }
 7 
 8     FirstLevel firstLevel =  new FirstLevel() {
 9 
10         public int x = 1;
11 
12         public static String str = "Hello World";   // 編譯報錯
13 
14         public static void aa() {        // 編譯報錯
15         }
16 
17         public static final String finalStr = "Hello World";  // 正常
18 
19         public void extraMethod() {  // 正常
20             // do something
21         }
22     };
23 }

(5)、匿名內部類可以有常量屬性（final修飾的屬性）；

(6)、匿名內部內中可以定義屬性，如上面代碼中的代碼:private int x = 1;

(7)、匿名內部內中可以可以有額外的方法（父介面、類中沒有的方法）;

(8)、匿名內部內中可以定義內部類；

(9)、匿名內部內中可以對其他類進行實例化。

4.匿名內部類實例

官方提供的兩個實例供大家參考：

實例一：

 1 import javafx.event.ActionEvent;
 2 import javafx.event.EventHandler;
 3 import javafx.scene.Scene;
 4 import javafx.scene.control.Button;
 5 import javafx.scene.layout.StackPane;
 6 import javafx.stage.Stage;
 7  
 8 public class HelloWorld extends Application {
 9     public static void main(String[] args) {
10         launch(args);
11     }
12     
13     @Override
14     public void start(Stage primaryStage) {
15         primaryStage.setTitle("Hello World!");
16         Button btn = new Button();
17         btn.setText("Say 'Hello World'");
18         btn.setOnAction(new EventHandler<ActionEvent>() {
19  
20             @Override
21             public void handle(ActionEvent event) {
22                 System.out.println("Hello World!");
23             }
24         });
25         
26         StackPane root = new StackPane();
27         root.getChildren().add(btn);
28         primaryStage.setScene(new Scene(root, 300, 250));
29         primaryStage.show();
30     }
31 }

實例二：

 1 import javafx.application.Application;
 2 import javafx.event.ActionEvent;
 3 import javafx.event.EventHandler;
 4 import javafx.geometry.Insets;
 5 import javafx.scene.Group;
 6 import javafx.scene.Scene;
 7 import javafx.scene.control.*;
 8 import javafx.scene.layout.GridPane;
 9 import javafx.scene.layout.HBox;
10 import javafx.stage.Stage;
11 
12 public class CustomTextFieldSample extends Application {
13     
14     final static Label label = new Label();
15  
16     @Override
17     public void start(Stage stage) {
18         Group root = new Group();
19         Scene scene = new Scene(root, 300, 150);
20         stage.setScene(scene);
21         stage.setTitle("Text Field Sample");
22  
23         GridPane grid = new GridPane();
24         grid.setPadding(new Insets(10, 10, 10, 10));
25         grid.setVgap(5);
26         grid.setHgap(5);
27  
28         scene.setRoot(grid);
29         final Label dollar = new Label("$");
30         GridPane.setConstraints(dollar, 0, 0);
31         grid.getChildren().add(dollar);
32         
33         final TextField sum = new TextField() {
34             @Override
35             public void replaceText(int start, int end, String text) {
36                 if (!text.matches("[a-z, A-Z]")) {
37                     super.replaceText(start, end, text);                     
38                 }
39                 label.setText("Enter a numeric value");
40             }
41  
42             @Override
43             public void replaceSelection(String text) {
44                 if (!text.matches("[a-z, A-Z]")) {
45                     super.replaceSelection(text);
46                 }
47             }
48         };
49  
50         sum.setPromptText("Enter the total");
51         sum.setPrefColumnCount(10);
52         GridPane.setConstraints(sum, 1, 0);
53         grid.getChildren().add(sum);
54         
55         Button submit = new Button("Submit");
56         GridPane.setConstraints(submit, 2, 0);
57         grid.getChildren().add(submit);
58         
59         submit.setOnAction(new EventHandler<ActionEvent>() {
60             @Override
61             public void handle(ActionEvent e) {
62                 label.setText(null);
63             }
64         });
65         
66         GridPane.setConstraints(label, 0, 1);
67         GridPane.setColumnSpan(label, 3);
68         grid.getChildren().add(label);
69         
70         scene.setRoot(grid);
71         stage.show();
72     }
73  
74     public static void main(String[] args) {
75         launch(args);
76     }
77 }

寫在最後：

這篇文章是我在閱讀官方文檔的同時加以自己的理解整理出來的，可能受英文原版的影響，有些地方表達得不准確或是不清楚還希望讀者能夠指正。另外，體會到了那些翻譯英文技術書的人確實不容易，英文的文章看上去意思都很清楚，但是想要再用中文表述出來卻不那麼容易。