Java内部类与匿名内部类

Java内部类：重点掌握匿名内部类

一、内部类概述

内部类（Inner Class）：定义在另一个类（称为外部类（Outer Class））内部的类。与之相对，直接定义在包下的类称为顶级类（Top-level Class）。
内部类是 Java 语言的一项重要特性，主要用于实现：

• 更强的封装性
• 逻辑上的关联性
• 间接的多重继承支持
• 简化回调函数的实现

Java 中的内部类分为四种类型：
成员内部类（Member Inner Class）
静态内部类（Static Nested Class）
局部内部类（Local Inner Class）
匿名内部类（Anonymous Inner Class）
匿名内部类是较常用的一种。

二、基本格式与用法

1. 成员内部类

基本格式：

publicclassOuter{// 成员内部类classInner{publicvoidmethod(){System.out.println("成员内部类方法");}}}

基本用法：

// 必须先创建外部类实例，再创建内部类实例Outerouter=newOuter();Outer.Innerinner=outer.newInner();inner.method();

核心特点：可访问外部类所有成员，依赖外部类实例存在。

2. 静态内部类

基本格式：

publicclassOuter{// 静态内部类staticclassStaticInner{publicvoidmethod(){System.out.println("静态内部类方法");}}}

基本用法：

// 直接创建，无需外部类实例Outer.StaticInnerinner=newOuter.StaticInner();inner.method();

核心特点：只能访问外部类静态成员，不依赖外部类实例。

3. 局部内部类

基本格式：

publicclassOuter{publicvoidouterMethod(){// 局部内部类（定义在方法内部）classLocalInner{publicvoidmethod(){System.out.println("局部内部类方法");}}// 只能在定义它的方法内部使用LocalInnerinner=newLocalInner();inner.method();}}

核心特点：作用域仅限于定义它的方法，不能使用访问修饰符。

三、匿名内部类（重点详解）

3.1 本质与定义

匿名内部类：没有显式类名的局部内部类。

本质：创建一个继承指定父类或实现指定接口的匿名子类的实例。它将"定义类"和"创建对象"两个步骤合并为一步完成。

3.2 基本语法

new父类/接口(构造参数列表){// 类体：重写父类/接口的方法，定义成员变量和方法};

3.3 三种核心使用场景

场景1：实现接口（最常用）

// 定义一个接口interfaceGreeting{voidsayHello(Stringname);}publicclassTest{publicstaticvoidmain(String[]args){// 使用匿名内部类实现Greeting接口Greetinggreeting=newGreeting(){@OverridepublicvoidsayHello(Stringname){System.out.println("Hello, "+name+"!");}};greeting.sayHello("Java");// 输出：Hello, Java!}}

场景2：继承抽象类

// 定义一个抽象类abstractclassAnimal{publicabstractvoidmakeSound();}publicclassTest{publicstaticvoidmain(String[]args){// 使用匿名内部类继承Animal抽象类Animaldog=newAnimal(){@OverridepublicvoidmakeSound(){System.out.println("汪汪汪！");}};dog.makeSound();// 输出：汪汪汪！}}

场景3：作为方法参数传递（最实用）

这是匿名内部类在实际开发中最常见的用法，用于向方法传递回调函数。

importjava.util.Arrays;importjava.util.Comparator;publicclassTest{publicstaticvoidmain(String[]args){Integer[]numbers={5,2,9,1,5,6};// 将匿名内部类作为Comparator参数传递给sort方法Arrays.sort(numbers,newComparator<Integer>(){@Overridepublicintcompare(Integera,Integerb){// 降序排序returnb-a;}});System.out.println(Arrays.toString(numbers));// 输出：[9, 6, 5, 5, 2, 1]}}

3.4 核心特性详解

1. 无类名特性

   • 匿名内部类没有显式的类名
   • 编译器自动生成类名，格式为：外部类名$数字.class
   • 只能在定义处创建一个实例，无法在其他地方使用

2. 继承/实现限制

   • 只能继承一个父类或实现一个接口
   • 不能同时继承类和实现接口，也不能实现多个接口

3. 构造方法限制

   • 不能定义显式的构造方法（因为没有类名）
   • 若需要初始化操作，可以使用实例初始化块

   publicclassInitExample{publicstaticvoidmain(String[]args){Personperson=newPerson(){// 实例初始化块，替代构造方法{setName("张三");setAge(20);}@Overridepublicvoidintroduce(){System.out.println("我叫"+getName()+"，今年"+getAge()+"岁");}};person.introduce();}}classPerson{privateStringname;privateintage;publicvoidintroduce(){}// getter和setter方法publicStringgetName(){returnname;}publicvoidsetName(Stringname){this.name=name;}publicintgetAge(){returnage;}publicvoidsetAge(intage){this.age=age;}}

4. 变量访问特性

   • 可以访问外部类的所有成员（包括私有成员）
   • 可以访问方法中的final或effectively final局部变量（Java 8+）
   • effectively final：变量虽然没有被final修饰，但在初始化后没有被重新赋值

四：从Lambda反推：彻底搞懂匿名内部类的本质

如果我们从"只有一个方法的接口才能用Lambda"这个最直观的规则，反过来推导匿名内部类的本质。你就会发现其中的机制的巧妙性，Lambda表达式就像一面镜子，能让你清晰地看到匿名内部类中哪些是"真正有用的代码"，哪些是"不得不写的仪式性代码"。

1.先明确：匿名内部类到底在做什么？

匿名内部类的本质，用一句话说就是：
它同时做了两件事：1. 定义一个类；2. 创建这个类的一个对象

而它定义的这个类，永远只有一个目的：实现一个接口，或者继承一个类。

2.当接口只有一个方法时：匿名内部类的冗余性暴露无遗

这是理解两者关系的关键。当接口只有一个方法时，匿名内部类的代码会出现大量的冗余，而Lambda表达式就是为了消除这些冗余而生的。

2.1 完整的匿名内部类写法

// 函数式接口：只有一个抽象方法interfaceRunnable{voidrun();}// 匿名内部类实现Runnabletask=newRunnable(){@Overridepublicvoidrun(){// 这是唯一真正有用的代码System.out.println("任务执行中");}};

2.2 逐行分析：哪些是多余的？

我们把这段代码拆开来，一行一行看：

1. new Runnable()：告诉编译器"我要创建一个实现了Runnable接口的类"
2. {：类的开始
3. @Override：告诉编译器"我要重写接口中的方法"
4. public void run()：告诉编译器"我要重写的是run方法"
5. {：方法的开始
6. System.out.println("任务执行中");：唯一真正有用的代码
7. }：方法的结束
8. }：类的结束
9. ;：语句的结束

你会发现，在这9行代码中，只有1行是我们真正关心的业务逻辑。其他8行都是"仪式性的代码"——它们是Java语法规则要求我们必须写的，但没有任何业务价值。

2.3 为什么这些代码可以被省略？

因为当接口只有一个方法时，所有这些仪式性代码都可以被编译器自动推断出来：

• 编译器从左边的变量类型Runnable，就知道你要实现的是Runnable接口
• 编译器从Runnable接口只有一个方法，就知道你要重写的是run()方法
• 编译器从run()方法的签名，就知道它没有参数，没有返回值

既然编译器都知道了，那我们为什么还要写呢？

2.4 Lambda表达式：只保留真正有用的代码

Lambda表达式就是把所有这些可以被推断出来的仪式性代码全部去掉，只保留两个最核心的部分：

1. 方法的参数列表：()表示没有参数
2. 方法的方法体：System.out.println("任务执行中")

中间用箭头->连接，就变成了：

Runnabletask=()->System.out.println("任务执行中");

这就是Lambda表达式的全部！它没有任何奇妙的转化，只是匿名内部类在"实现单方法接口"这种特定情况下的极致简写。

3.反过来理解：为什么多方法接口不能用Lambda？

现在我们把接口改成有两个方法：

// 不是函数式接口：有两个抽象方法interfaceCalculator{intadd(inta,intb);intsubtract(inta,intb);}

3.1 匿名内部类实现

Calculatorcalc=newCalculator(){@Overridepublicintadd(inta,intb){returna+b;}@Overridepublicintsubtract(inta,intb){returnb-a;}};

3.2 问题来了：你怎么把它改成Lambda？

你根本做不到！因为：

• 这里有两个不同的方法实现
• Lambda表达式只能写一段代码
• 编译器无法知道你这段代码对应的是add方法还是subtract方法

这就是为什么只有一个方法的接口才能用Lambda的根本原因。

反过来想：如果一个接口能用Lambda表达式实现，那么它对应的匿名内部类一定是"只重写了一个方法"的。这就是匿名内部类最常见、最典型的使用场景。

4、一个完整的演变过程：从最原始到最简洁

为了让你彻底理解，我们用一个完整的例子，展示从最原始的方式到Lambda表达式的完整演变过程。每一步你都能清楚地看到，我们去掉了什么，为什么可以去掉。

步骤1：最原始的方式：单独写一个类

// 1. 定义接口interfaceGreeting{voidsayHello(Stringname);}// 2. 单独写一个实现类classEnglishGreetingimplementsGreeting{@OverridepublicvoidsayHello(Stringname){System.out.println("Hello, "+name+"!");}}// 3. 使用publicclassTest{publicstaticvoidmain(String[]args){Greetinggreeting=newEnglishGreeting();greeting.sayHello("Java");}}

问题：如果这个EnglishGreeting类只需要用一次，单独写一个文件太麻烦了。

步骤2：第一次简化：用匿名内部类

interfaceGreeting{voidsayHello(Stringname);}publicclassTest{publicstaticvoidmain(String[]args){// 把"定义类"和"创建对象"合并成一步Greetinggreeting=newGreeting(){@OverridepublicvoidsayHello(Stringname){System.out.println("Hello, "+name+"!");}};greeting.sayHello("Java");}}

改进：不需要单独写一个类文件了。
问题：仍然有很多仪式性的代码。

步骤3：第二次简化：用Lambda表达式

interfaceGreeting{voidsayHello(Stringname);}publicclassTest{publicstaticvoidmain(String[]args){// 去掉所有可以被推断的仪式性代码Greetinggreeting=name->System.out.println("Hello, "+name+"!");greeting.sayHello("Java");}}

改进：代码变得极其简洁，一眼就能看到核心逻辑。

现在，你应该彻底理解匿名内部类了

通过和Lambda表达式的对比，我们可以知道匿名内部类是Java在没有Lambda表达式的时代，为了实现"传递一段代码"这个需求，而设计的一种解决方案。它通过"定义一个匿名类并立即创建对象"的方式，间接实现了代码的传递。
而Lambda表达式的出现，就是为了简化匿名内部类最常见的使用场景——实现单方法接口。

匿名内部类的不可替代性：
虽然Lambda表达式很简洁，但它并不能完全替代匿名内部类。匿名内部类还有一些Lambda表达式做不到的事情：

1. 实现多方法接口：这是Lambda表达式永远做不到的
2. 继承一个类：Lambda表达式只能实现接口，不能继承类
3. 定义成员变量和方法：匿名内部类可以有自己的成员变量和方法
4. 重写多个方法：匿名内部类可以重写父类的多个方法