Java 匿名内部类

官方文档 https://docs.oracle.com/javase/tutorial/java/javaOO/anonymousclasses.html#declaring-anonymous-classes

博主大大的翻译 https://www.cnblogs.com/wuhenzhidu/p/anonymous.html

自己的记录

1.为什么有匿名内部类？

官方说匿名内部类的使用会让你的代码更加简洁，因为你可以在定义一个类的同时进行实例化。

它和局部类很相似，不同的是它没有类名，如果某个局部类你只需要用一次，你就可以用匿名内部类。

2.如何使用匿名内部类？

2.1匿名内部类与局部类对比

public class Anonymous1 {

    /**
     * 包含两个方法的HelloWorld接口
     */
    interface HelloWorld {
        public void greet();
        public void greetSomeone(String someone);
    }

    public void sayHello() {

        // 1、局部类EnglishGreeting实现了HelloWorld接口
        class EnglishGreeting implements HelloWorld {
            String name = "world";
            public void greet() {
                greetSomeone("world");
            }
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("Hello " + name);
            }
        }

        HelloWorld englishGreeting = new EnglishGreeting();

        // 2、匿名类实现HelloWorld接口
        HelloWorld frenchGreeting = new HelloWorld() {
            String name = "tout le monde";
            public void greet() {
                greetSomeone("tout le monde");
            }
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("Salut " + name);
            }
        };

        // 3、匿名类实现HelloWorld接口
        HelloWorld spanishGreeting = new HelloWorld() {
            String name = "mundo";
            public void greet() {
                greetSomeone("mundo");
            }
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("Hola, " + name);
            }
        };

        englishGreeting.greet();
        frenchGreeting.greetSomeone("Fred");
        spanishGreeting.greet();
    }

    public static void main(String... args) {
        Anonymous1 myApp = new Anonymous1();
        myApp.sayHello();
    }
}

1. 局部类是类声明，匿名内部类是表达式
2. 局部类EnglishGreeting 需要先继承HelloWorld接口，然后通过new关键字进行实例化
3. frenchGreeting、spanishGreeting在定义的时候就可以直接实例化，定义完就可以直接使用
4. 匿名类是表达式是语句的一部分所以末尾要用；结尾

2.2匿名内部类的语法

匿名类是一个表达式，匿名类的语法就类似于调用一个类的构建函数（new  HelloWorld()），除些之外，还包含了一个代码块，在代码块中完成类的定义

实现接口的匿名类，同上

实现匿名子类（继承父类）

public class Anonymous2 {

    private final String ANIMAL = "动物";

    public void accessTest() {
        System.out.println("匿名内部类访问其外部类方法");
    }

    class Animal {
        private String name;

        public Animal(String name) {
            this.name = name;
        }

        public void printAnimalName() {
            System.out.println(bird.name);
        }
    }

    // 鸟类，匿名子类，继承自Animal类，可以覆写父类方法
    Animal bird = new Animal("布谷鸟") {

        @Override
        public void printAnimalName() {
            accessTest();  // 访问外部类成员
            System.out.println(ANIMAL);  // 访问外部类final修饰的变量
            super.printAnimalName();
        }
    };

    public void print() {
        bird.printAnimalName();
    }

    public static void main(String[] args) {

        Anonymous2 animalTest = new Anonymous2();
        animalTest.print();
    }
}

匿名类表达式包含以下

1. 操作符：new
2. 要实现的接口或要扩展的类的名称
3. 匿名子类时需要包含构造函数参数的圆括号；如果是实现一个接口就用一对空的圆括号
4. {}：类声明主体。在主体中，可以方法声明，不能声明语句
5. 匿名类定义是一个表达式，所以它必须是语句的一部分，所以结尾添加；号

3.匿名内部类使用需注意的地方

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

1. 匿名内部类可以访问外部类的所有成员
2. 匿名内部类可以访问外部类成员
3. 匿名内部类不能访问外部类未加final修饰的变量
4. 属性屏蔽：与内嵌类相同，匿名内部类会屏蔽其作用域内相同名称的其他声明（变量）

   public class Anonymous4 {
       public int x = 0;
   
       interface FirstLevel {
           void methodInFirstLevel(int x);
       }
   
       FirstLevel firstLevel =  new FirstLevel() {
   
           public int x = 1;
   
           @Override
           public void methodInFirstLevel(int x) {
               System.out.println("x = " + x);
               System.out.println("this.x = " + this.x);
               System.out.println("Anonymous4.this.x = " + Anonymous4.this.x);
           }
       };
   
       public static void main(String... args) {
           Anonymous4 st = new Anonymous4();
           Anonymous4.FirstLevel fl = st.firstLevel;
           fl.methodInFirstLevel(23);
       }
   }

   

可以看到这里面有三个X变量：外部类成员x=0；匿名类成员x=1；匿名类内方法的参数

根据结果可以看到参数屏蔽了外面的成员，如果想要在方法内使用类成员需要加上关键字this来指定引用的是成员变量

如果利用类名来应用其成员变量具有最高优先级，不会被屏蔽

  5.匿名内部类不能定义静态属性或方法

public class Anonymous5 {
    public int x = 0;

    interface FirstLevel {
        void methodInFirstLevel(int x);
    }

    FirstLevel firstLevel = new FirstLevel() {

        public int x = 1;
        @Override
        public void methodInFirstLevel(int x){
            System.out.println(x);
        }

//        public static String str = "Hello World";   // 编译报错

//        public static void aa() {        // 编译报错
//        }
        // 匿名内部类中不能定义静态属性、方法

        public static final String finalStr = "Hello World";  // 正常
        // 匿名内部类中可以有常量属性（必须用final修饰属性）

        public void extraMethod() {  // 正常
            // do something
        }
    };
}

  6.匿名内部类可以有用final修饰的常量属性

  7.匿名内部类可以声明属性

  8.可以声明方法（父接口，父类中没有的方法）

  9.可以声明内部类

  10.可以对其他类进行实例化

  11.不能再匿名类中声明构造方法

实例一：

import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;
import javafx.application.Application;

public class Anonymous6 extends Application {
    public static void main(String[] args) {
        launch(args);
    }

    @Override
    public void start(Stage primaryStage) {
        primaryStage.setTitle("Hello World!");
        Button btn = new Button();
        btn.setText("Say 'Hello World'");
        btn.setOnAction(new EventHandler<ActionEvent>() {

            @Override
            public void handle(ActionEvent event) {
                System.out.println("Hello World!");
            }
        });

        StackPane root = new StackPane();
        root.getChildren().add(btn);
        primaryStage.setScene(new Scene(root, 300, 250));
        primaryStage.show();
    }
}

实列二：

import javafx.application.Application;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.geometry.Insets;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.control.*;
import javafx.scene.layout.GridPane;
import javafx.scene.layout.HBox;
import javafx.stage.Stage;

public class Anonymous7 extends Application {

    final static Label label = new Label();

    @Override
    public void start(Stage stage) {
        Group root = new Group();
        Scene scene = new Scene(root, 300, 150);
        stage.setScene(scene);
        stage.setTitle("Text Field Sample");

        GridPane grid = new GridPane();
        grid.setPadding(new Insets(10, 10, 10, 10));
        grid.setVgap(5);
        grid.setHgap(5);

        scene.setRoot(grid);
        final Label dollar = new Label("$");
        GridPane.setConstraints(dollar, 0, 0);
        grid.getChildren().add(dollar);

        final TextField sum = new TextField() {
            @Override
            public void replaceText(int start, int end, String text) {
                if (!text.matches("[a-z, A-Z]")) {
                    super.replaceText(start, end, text);
                }
                label.setText("Enter a numeric value");
            }

            @Override
            public void replaceSelection(String text) {
                if (!text.matches("[a-z, A-Z]")) {
                    super.replaceSelection(text);
                }
            }
        };

        sum.setPromptText("Enter the total");
        sum.setPrefColumnCount(10);
        GridPane.setConstraints(sum, 1, 0);
        grid.getChildren().add(sum);

        Button submit = new Button("Submit");
        GridPane.setConstraints(submit, 2, 0);
        grid.getChildren().add(submit);

        submit.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent e) {
                label.setText(null);
            }
        });

        GridPane.setConstraints(label, 0, 1);
        GridPane.setColumnSpan(label, 3);
        grid.getChildren().add(label);

        scene.setRoot(grid);
        stage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }
}

学习这个主要是为了理解java8的新特性，lambda表达式