java的匿名内部类-使用new对象后接大括号{}

public class Student {
    String name ;
 
    public static void main(String[] args) {
 
        //第一种情况，初始化一个对象
        Student s = new Student(){
            String name = "chengho";
        };
 
        //第二种情况，匿名内部类，实例化一个接口
        Person p = new Person(){
 
            @Override
            public void setName() {
                //随便写点什么
                System.out.println("测试setName");
            }
        };
        
        //检测是否实例化
        p.setName();
    }
 
}
 
//测试用的接口
interface Person{
    void setName();
}

eg：匿名内部类与红框里面的class是等价的，只是第一种方式顺便也实例化了。

https://www.cnblogs.com/wuhenzhidu/p/anonymous.html

1.前言

匿名内部类在我们JAVA程序员的日常工作中经常要用到，但是很多时候也只是照本宣科地用，虽然也在用，但往往忽略了以下几点：为什么能这么用？匿名内部类的语法是怎样的？有哪些限制？因此，最近，我在完成了手头的开发任务后，查阅了一下JAVA官方文档，将匿名内部类的使用进行了一下总结，案例也摘自官方文档。感兴趣的可以查阅官方文档。

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 定义匿名内部类

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

 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 }

运行结果：

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

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

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