JAVA匿名内部类(Anonymous Classes)

Love The Way You Lie 2022-10-17 04:14 172阅读 0赞

## 1.前言 ##

匿名内部类在我们JAVA程序员的日常工作中经常要用到，但是很多时候也只是照本宣科地用，虽然也在用，但往往忽略了以下几点：为什么能这么用？匿名内部类的语法是怎样的？有哪些限制？因此，最近，我在完成了手头的开发任务后，查阅了一下JAVA官方文档，将匿名内部类的使用进行了一下总结，案例也摘自官方文档。感兴趣的可以查阅官方文档（[https://docs.oracle.com/javase/tutorial/java/javaOO/anonymousclasses.html][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.）

本节包括以下几个方面：

1.  定义匿名内部类
2.  匿名内部类的语法
3.  访问作用域的局部变量、定义和访问匿名内部类成员
4.  匿名内部类实例

### 2.1 定义匿名内部类 ###

首先看下官方文档中给的例子：

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

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 }

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

运行结果为：

1 Hello world
    2 Salut Fred
    3 Hola, mundo

该例中用局部类来初始化变量englishGreeting，用匿类来初始化变量frenchGreeting和spanishGreeting，两种实现之间有明显的区别：

> 1）局部类EnglishGreetin继承HelloWorld接口，有自己的类名，定义完成之后需要再用new关键字实例化才可以使用；
> 
> 2）frenchGreeting、spanishGreeting在定义的时候就实例化了，定义完了就可以直接使用；
> 
> 3）匿名类是一个表达式，因此在定义的最后用分号";"结束。

### 2.2 匿名内部类的语法 ###

如上文所述，匿名类是一个表达式，匿名类的语法就类似于调用一个类的构建函数（new  HelloWorld()），除些之外，还包含了一个代码块，在代码块中完成类的定义，见以下两个实例：

**案例一，实现接口的匿名类：**

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

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  };

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

** 案例二，匿名子类（继承父类）：**

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

1 public class AnimalTest {
     2 
     3     private final String ANIMAL = "动物";
     4 
     5     public void accessTest() {
     6         System.out.println("匿名内部类访问其外部类方法");
     7     }
     8     //内部类-dapeng
     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 }

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

运行结果：

运行结果：
    匿名内部类访问其外部类方法
    动物
    布谷鸟

从以上两个实例中可知，匿名类表达式包含以下内部分：

> 1.  操作符：new；
> 2.  一个要实现的接口或要继承的类，案例一中的匿名类实现了HellowWorld接口，案例二中的匿名内部类继承了Animal父类；（接口匿名类和子类匿名类【重写父类属性或者方法】）
> 3.  一对括号，如果是匿名子类，与实例化普通类的语法类似，如果有构造参数，要带上构造参数；如果是实现一个接口，只需要一对空括号即可；
> 4.  一段被"\{\}"括起来类声明主体；
> 5.  末尾的";"号（因为匿名类的声明是一个表达式，是语句的一部分，因此要以分号结尾）。

## 3.访问作用域内的局部变量、定义和访问匿名内部类成员 ##

匿名内部类与局部类对作用域内的变量拥有相同的的访问权限。

> (1)、匿名内部类可以访问外部内的所有成员；
> 
> (2)、匿名内部类不能访问外部类未加final修饰的变量（注意：JDK1.8即使没有用final修饰也可以访问）；
> 
> (3)、属性屏蔽，与内嵌类相同，匿名内部类定义的类型（如变量）会屏蔽其作用域范围内的其他同名类型（变量）：

** 案例一，内嵌类的属性屏蔽：**

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

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 }

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

输出结果为：

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);

** 案例二，匿名内部类的属性屏蔽：**

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

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 }

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

输出结果为：

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

(4)、**匿名内部类中不能定义静态属性、方法**；

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

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 }

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

(5)、匿名内部类可以有常量属性（final修饰的属性）；

(6)、匿名内部内中可以定义属性，如上面代码中的代码:private int x = 1;

(7)、匿名内部内中可以可以有额外的方法（父接口、类中没有的方法）;

(8)、匿名内部内中可以定义内部类；

(9)、匿名内部内中可以对其他类进行实例化。

## 4.匿名内部类实例 ##

官方提供的两个实例供大家参考：

**实例一：**

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

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 }

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

**实例二：**

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

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 }

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

## 写在最后： ##

这篇文章是我在阅读官方文档的同时加以自己的理解整理出来的，可能受英文原版的影响，有些地方表达得不准确或是不清楚还希望读者能够指正。另外，体会到了那些翻译英文技术书的人确实不容易，英文的文章看上去意思都很清楚，但是想要再用中文表述出来却不那么容易。

[https_docs.oracle.com_javase_tutorial_java_javaOO_anonymousclasses.html]: https://docs.oracle.com/javase/tutorial/java/javaOO/anonymousclasses.html
[48304ba5e6f9fe08f3fa1abda7d326ab.png]: /images/20221014/14e35a1a5e294ad99910ce8915b85ee3.png