播面

本文讲解Java匿名内部类：一种没有名字、只用一次的类。它能在创建对象时，即时实现一个接口或继承一个父类。

我们来详细地讲解一下Java中的匿名内部类（Anonymous Inner Class）。

1. 什么是匿名内部类？

匿名内部类，顾名思义，就是没有名字的内部类。

它是一种“即用即弃”的类，通常在你需要创建一个类的对象，而这个类的实现非常简单，只使用一次，并且不想为其单独创建一个 .java 文件或者命名一个完整的类时使用。

它的本质是：在创建实例的同时，定义并实现一个类。这个类要么是某个类（包括抽象类）的子类，要么是某个接口的实现类。

2. 为什么需要匿名内部类？

主要优点是代码简洁和作用域明确。

• 代码简洁：如果一个接口或类的实现逻辑非常简单，并且只在一个地方使用，使用匿名内部类可以省去定义一个新类的麻烦，让代码更紧凑。
• 作用域明确：实现逻辑直接定义在使用它的地方，使得代码的上下文非常清晰，可读性更强。

最经典的场景就是GUI编程中的事件监听器（Event Listener）和多线程中的 Runnable 对象。

3. 语法结构

匿名内部类的语法比较特殊，它结合了声明和实例化。

基本语法：

new SuperType(construction_parameters) {
    // 匿名内部类的类体
    // 可以包含字段、方法、实例初始化块等
    // 这里会重写SuperType的方法或实现接口的方法
}; // 注意这里有个分号

语法解析：

1. new：创建对象的关键字。
2. SuperType：可以是一个接口名或一个类名。
   • 如果是接口名，那么这个匿名内部类就实现了这个接口。
   • 如果是类名，那么这个匿名内部类就继承了这个类。
3. ()：括号。如果 SuperType 是一个类，这里可以传递构造方法的参数。如果 SuperType 是接口，则括号必须为空。
4. {}：大括号内是匿名内部类的类体，你可以在这里定义字段、方法，并重写父类或实现接口的方法。
5. ;：整个匿名内部类表达式的结束符。因为它是一个表达式，通常作为方法参数或赋值给一个变量，所以后面需要分号。

4. 示例

让我们通过几个经典的例子来理解。

示例1：实现接口 (Runnable)

在Java 8之前，创建线程最常见的方式就是使用匿名内部类来实现 Runnable 接口。

public class AnonymousClassExample {
    public static void main(String[] args) {
        // 创建一个实现了 Runnable 接口的匿名内部类的实例
        Runnable myRunnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("这是一个匿名内部类实现的线程！");
            }
        };

        // 创建并启动线程
        Thread thread = new Thread(myRunnable);
        thread.start();

        // 也可以更简洁地直接作为参数传递
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("这是另一个直接传递的匿名内部类线程！");
            }
        }).start();
    }
}

在这个例子中，我们没有定义一个名为 MyRunnable 的类，而是直接在 new Thread() 的参数里创建了一个 Runnable 接口的实现。

示例2：继承抽象类

假设我们有一个抽象类 Animal。

abstract class Animal {
    abstract void makeSound();
}

public class AnonymousClassExample2 {
    public static void main(String[] args) {
        // 创建一个继承了 Animal 类的匿名内部类的实例
        Animal dog = new Animal() {
            @Override
            void makeSound() {
                System.out.println("汪汪汪！");
            }
        };

        dog.makeSound(); // 输出: 汪汪汪！

        Animal cat = new Animal() {
            @Override
            void makeSound() {
                System.out.println("喵喵喵！");
            }
        };
        cat.makeSound(); // 输出: 喵喵喵！
    }
}

这里，我们为 dog 和 cat 分别创建了两个不同的 Animal 的子类实例，但都没有给这些子类命名。

5. 关键特性与限制

1. 没有名字：这是它最核心的特点。因此，你不能在其他地方复用这个类定义。

2. 不能有构造方法：因为它没有名字，所以无法声明构造方法（构造方法名必须和类名相同）。但是，你可以使用实例初始化块来达到类似构造方法的效果。

   java

   new Thread(new Runnable() {
       private String message;
   
       // 实例初始化块，类似构造方法
       {
           message = "Hello from initializer block!";
           System.out.println("实例初始化块被执行了");
       }
   
       @Override
       public void run() {
           System.out.println(message);
       }
   }).start();

3. 访问局部变量的限制：匿名内部类可以访问其所在方法中的局部变量，但这些变量必须是 final 或事实上的 final（Effectively Final）。

   • final：明确用 final 关键字修饰。
   • 事实上的 final（Java 8+）：指这个变量在初始化后，其值没有再被改变过。编译器会自动把它当作 final 对待。

   为什么有这个限制？
   因为局部变量存在于栈上，当方法执行完毕后，栈帧就会被销毁，局部变量也就不存在了。但此时，匿名内部类的对象可能还存在于堆上（比如线程还在运行）。为了让内部类在方法结束后还能访问这个变量，Java编译器会拷贝一份变量的副本给匿名内部类。为了保证这个副本和原始值的一致性，就规定了该变量不能被修改。

   java

   public void someMethod() {
       final String finalMessage = "Hello"; // final 变量
       String effectiveFinalMessage = "World"; // 事实上的 final 变量
       String changingMessage = "Initial"; // 非 final 变量
   
       new Thread(new Runnable() {
           @Override
           public void run() {
               System.out.println(finalMessage); // OK
               System.out.println(effectiveFinalMessage); // OK
               // System.out.println(changingMessage); // 编译错误！
           }
       }).start();
   
       changingMessage = "Changed"; // 因为这里改变了它，所以它不是事实上的 final
   }

4. 不能是 static 的：匿名内部类不能声明为 static。

5. 不能包含静态成员：除了 static final 的常量外，匿名内部类中不能有任何静态成员（字段或方法）。

6. 与 Lambda 表达式的对比 (Java 8+)

从Java 8开始，引入了 Lambda 表达式，它在很多场景下可以替代匿名内部类，代码更加简洁。

Lambda 表达式只能用于实现只有一个抽象方法的接口，即函数式接口（Functional Interface）。

对比：

使用匿名内部类（Runnable 是函数式接口）：

new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Anonymous Inner Class way.");
    }
}).start();

使用 Lambda 表达式：

new Thread(() -> System.out.println("Lambda way.")).start();

可以看到，Lambda 表达式写法非常简洁。

什么时候必须用匿名内部类而不能用 Lambda？

1. 需要实现的接口有多个抽象方法时。
2. 需要继承一个类（包括抽象类）时。
3. 需要在内部类中定义实例字段或多个方法时。 Lambda 表达式是无状态的，只能包含一段执行逻辑。
4. 当 this 关键字的指向很重要时。
   • 在匿名内部类中，this 指向匿名内部类自身的对象。
   • 在Lambda 表达式中，this 指向其外部的类对象（即定义 Lambda 的那个类）。

总结

总的来说，匿名内部类是Java中一个强大而灵活的工具。虽然在函数式接口的场景下，Lambda 表达式是更现代、更简洁的选择，但在需要继承类或实现多方法接口的“一次性”场景中，匿名内部类依然是不可或缺的。