匿名类可以使你代码更简洁，它们使你能够同时声明和实例化一个类，它们就像局部类，除了它们没有名称，如果你只需要使用局部类一次，请使用它们。

声明匿名类

虽然局部类是类声明，但匿名类是表达式，这意味着你在另一个表达式中定义该类，以下示例HelloWorldAnonymousClasses在局部变量frenchGreeting和spanishGreeting的初始化语句中使用匿名类，但使用局部类初始化变量englishGreeting：

  1. public class HelloWorldAnonymousClasses {
  3.     interface HelloWorld {
  4.         public void greet();
  5.         public void greetSomeone(String someone);
  6.     }
  8.     public void sayHello() {
  10.         class EnglishGreeting implements HelloWorld {
  11.             String name = "world";
  12.             public void greet() {
  13.                 greetSomeone("world");
  14.             }
  15.             public void greetSomeone(String someone) {
  16.                 name = someone;
  17.                 System.out.println("Hello " + name);
  18.             }
  19.         }
  21.         HelloWorld englishGreeting = new EnglishGreeting();
  23.         HelloWorld frenchGreeting = new HelloWorld() {
  24.             String name = "tout le monde";
  25.             public void greet() {
  26.                 greetSomeone("tout le monde");
  27.             }
  28.             public void greetSomeone(String someone) {
  29.                 name = someone;
  30.                 System.out.println("Salut " + name);
  31.             }
  32.         };
  34.         HelloWorld spanishGreeting = new HelloWorld() {
  35.             String name = "mundo";
  36.             public void greet() {
  37.                 greetSomeone("mundo");
  38.             }
  39.             public void greetSomeone(String someone) {
  40.                 name = someone;
  41.                 System.out.println("Hola, " + name);
  42.             }
  43.         };
  44.         englishGreeting.greet();
  45.         frenchGreeting.greetSomeone("Fred");
  46.         spanishGreeting.greet();
  47.     }
  49.     public static void main(String... args) {
  50.         HelloWorldAnonymousClasses myApp =
  51.             new HelloWorldAnonymousClasses();
  52.         myApp.sayHello();
  53.     }            
  54. }

匿名类的语法

如前所述，匿名类是表达式，匿名类表达式的语法类似于构造函数的调用，除了代码块中包含类定义。

考虑frenchGreeting对象的实例化：

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

匿名类表达式包含以下内容：

  • new运算符。
  • 要实现的接口的名称或要继承的类，在此示例中，匿名类正在实现接口HelloWorld。
  • 包含构造函数参数的圆括号，就像普通的类实例创建表达式一样，注意：实现接口时，没有构造函数，因此你使用一对空括号，如本例所示。
  • 类声明体，更具体地说，类体中，方法声明是允许的，但语句不是。

因为匿名类定义是表达式，所以它必须是语句的一部分，在此示例中，匿名类表达式是实例化frenchGreeting对象的语句的一部分（这解释了为什么在闭合花括号后有一个分号）。

访问封闭范围的局部变量，以及声明和访问匿名类的成员

与局部类一样，匿名类可以捕获变量，它们对封闭范围的局部变量具有相同的访问权限：

  • 匿名类可以访问其封闭类的成员。
  • 匿名类无法访问其封闭范围中未声明为final或者实际为final的局部变量。
  • 与嵌套类一样，匿名类中的类型（例如变量）的声明会影响封闭范围中具有相同名称的任何其他声明，有关更多信息，请参阅遮蔽。

匿名类对其成员也具有与局部类相同的限制：

  • 你不能在匿名类中声明静态初始化或成员接口。
  • 匿名类可以具有静态成员，前提是它们是常量变量。

请注意，你可以在匿名类中声明以下内容：

  • 字段
  • 额外的方法（即使他们没有实现超类型的任何方法）
  • 实例初始化
  • 局部类

但是，你不能在匿名类中声明构造函数。

匿名类的示例

匿名类通常用于图形用户界面（GUI）应用程序。

考虑JavaFX示例HelloWorld.java（来自Hello World的部分，来自JavaFX入门的JavaFX样式），此示例创建一个包含Say ‘Hello World’按钮的frame：

  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;
  8. public class HelloWorld extends Application {
  9.     public static void main(String[] args) {
  10.         launch(args);
  11.     }
  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>() {
  20.             @Override
  21.             public void handle(ActionEvent event) {
  22.                 System.out.println("Hello World!");
  23.             }
  24.         });
  26.         StackPane root = new StackPane();
  27.         root.getChildren().add(btn);
  28.         primaryStage.setScene(new Scene(root, 300, 250));
  29.         primaryStage.show();
  30.     }
  31. }

在此示例中，方法调用btn.setOnAction指定当你选择Say 'Hello World'按钮时会发生什么，此方法需要EventHandler<ActionEvent>类型的对象，EventHandler<ActionEvent>接口只包含一个方法handle。该示例使用匿名类表达式，而不是使用新类实现此方法，请注意，此表达式是传递给btn.setOnAction方法的参数。

因为EventHandler<ActionEvent>接口只包含一个方法，所以可以使用lambda表达式而不是匿名类表达式，有关更多信息，请参阅Lambda表达式一节。

匿名类是实现包含两个或更多方法的接口的理想选择，以下JavaFX示例来自UI控件的自定义部分，匿名类代码创建一个只接受数值的文本字段，它通过重写从TextInputControl类继承的replaceText和replaceSelection方法，使用匿名类重新定义TextField类的默认实现。

  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;
  12. public class CustomTextFieldSample extends Application {
  14.     final static Label label = new Label();
  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");
  23.         GridPane grid = new GridPane();
  24.         grid.setPadding(new Insets(10, 10, 10, 10));
  25.         grid.setVgap(5);
  26.         grid.setHgap(5);
  28.         scene.setRoot(grid);
  29.         final Label dollar = new Label("$");
  30.         GridPane.setConstraints(dollar, 0, 0);
  31.         grid.getChildren().add(dollar);
  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.             }
  42.             @Override
  43.             public void replaceSelection(String text) {
  44.                 if (!text.matches("[a-z, A-Z]")) {
  45.                     super.replaceSelection(text);
  46.                 }
  47.             }
  48.         };
  50.         sum.setPromptText("Enter the total");
  51.         sum.setPrefColumnCount(10);
  52.         GridPane.setConstraints(sum, 1, 0);
  53.         grid.getChildren().add(sum);
  55.         Button submit = new Button("Submit");
  56.         GridPane.setConstraints(submit, 2, 0);
  57.         grid.getChildren().add(submit);
  59.         submit.setOnAction(new EventHandler<ActionEvent>() {
  60.             @Override
  61.             public void handle(ActionEvent e) {
  62.                 label.setText(null);
  63.             }
  64.         });
  66.         GridPane.setConstraints(label, 0, 1);
  67.         GridPane.setColumnSpan(label, 3);
  68.         grid.getChildren().add(label);
  70.         scene.setRoot(grid);
  71.         stage.show();
  72.     }
  74.     public static void main(String[] args) {
  75.         launch(args);
  76.     }
  77. }

上一篇：局部类

下一篇：Lambda表达式