基于本文回答

播面 播面

文图音视，全方位拆解八股文
0
评论
请从左侧选择一个分类

Java匿名内部类详解

知识点图片

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

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

1. 什么是匿名内部类？

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

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

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

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

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

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

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

3. 语法结构

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

基本语法：

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

语法解析：

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

4. 示例

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

示例1：实现接口 (Runnable)

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

java 
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。

java 
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 是函数式接口）：

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

使用 Lambda 表达式：

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

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

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

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

总结

特性 匿名内部类 Lambda 表达式
用途 实现接口或继承类 仅实现函数式接口
this 指向 指向自身实例 指向外部类实例
状态 可以拥有实例字段，有状态 无状态
代码量 相对冗长 非常简洁
适用版本 Java 1.1+ Java 8+

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

00:00
00:00