文章目录
什么是内部类？1. 成员内部类 (Member Inner Class)2. 局部内部类 (Local Inner Class)3. 匿名内部类 (Anonymous Inner Class)4. 静态内部类 (Static Nested Class)为什么使用内部类？内部类对比概览内部类与外部类的联系：编译器如何处理？
Java 作为一门面向对象的语言，其强大的特性之一就是类的组织和封装。除了我们最常见的独立类之外，Java 还提供了一种独特的机制——内部类（Inner Class）。内部类允许在一个类的内部定义另一个类，这不仅提供了更好的封装性，还在某些设计模式和特定场景下展现出极大的灵活性和便利性。
什么是内部类？
简单来说，内部类是定义在另一个类（通常称为外部类或宿主类）的内部的类。内部类可以直接访问外部类的所有成员，包括私有成员，这是它与普通类最主要的区别。
内部类可以分为四种主要类型：
成员内部类 (Member Inner Class)局部内部类 (Local Inner Class)匿名内部类 (Anonymous Inner Class)静态内部类 (Static Nested Class)
接下来，我们逐一探讨它们。
1. 成员内部类 (Member Inner Class)
成员内部类是最常见的内部类类型，它就像外部类的成员变量一样，可以访问外部类的所有成员。
特点：
它需要依附于外部类的实例才能被创建。可以访问外部类的所有成员，包括私有成员。不能定义静态成员（除了 final static 常量）。
示例：
class OuterClass {
private int outerValue = 10;
class InnerClass { // 成员内部类
public void display() {
System.out.println("外部类的值: " + outerValue); // 可以访问外部类的私有成员
}
}
public void createAndUseInner() {
InnerClass inner = new InnerClass();
inner.display();
}
public static void main(String[] args) {
OuterClass outer = new OuterClass();
outer.createAndUseInner();
// 另一种创建内部类实例的方式
OuterClass.InnerClass anotherInner = outer.new InnerClass();
anotherInner.display();
}
}
使用场景： 当一个类只为另一个类服务，并且需要直接访问外部类的成员时，成员内部类是一个很好的选择。例如，实现某些辅助功能或者迭代器模式。
2. 局部内部类 (Local Inner Class)
局部内部类是定义在方法、构造器或代码块中的类。它的作用域仅限于定义它的代码块。
特点：
作用域仅限于定义它的方法或代码块。不能使用访问修饰符（public, private 等），因为它的作用域是局部的。可以访问外部类的所有成员。可以访问其所在方法或代码块中 final 或 有效 final 的局部变量。
示例：
class OuterClass {
private int outerValue = 20;
public void methodWithLocalInnerClass() {
int localVariable = 30; // 局部变量
// 局部内部类
class LocalInnerClass {
public void display() {
System.out.println("外部类的值: " + outerValue);
// 在Java 8及以后，localVariable 即使不加 final 关键字，
// 只要它在内部类中没有被修改，就会被认为是“有效 final”
System.out.println("局部变量: " + localVariable);
}
}
LocalInnerClass localInner = new LocalInnerClass();
localInner.display();
}
public static void main(String[] args) {
OuterClass outer = new OuterClass();
outer.methodWithLocalInnerClass();
}
}
使用场景： 当一个类只需要在某个特定方法内部使用一次时，局部内部类可以提高代码的封装性，避免污染外部类的命名空间。
3. 匿名内部类 (Anonymous Inner Class)
匿名内部类是没有名字的内部类，它通常用于创建一个接口的实现或一个类的子类的实例，并且只需要使用一次。
特点：
没有类名，不能定义构造器。必须在创建时同时实现其父类或接口的所有抽象方法。通常用于简化代码，特别是当需要一个简单的、一次性的实现时。可以访问外部类的所有成员以及所在方法中 final 或有效 final 的局部变量。
示例：
interface Greeting {
void sayHello();
}
class OuterClass {
public void greet() {
// 匿名内部类实现 Greeting 接口
Greeting englishGreeting = new Greeting() {
@Override
public void sayHello() {
System.out.println("Hello!");
}
};
englishGreeting.sayHello();
// 匿名内部类继承一个类
Thread myThread = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("匿名线程运行中...");
}
// 匿名内部类不能直接定义静态成员，但可以定义final static常量
// public static final int MY_CONST = 100;
});
myThread.start();
}
public static void main(String[] args) {
OuterClass outer = new OuterClass();
outer.greet();
}
}
使用场景： 事件监听器、线程创建（Runnable）、各种回调函数等场景中，匿名内部类非常常见，可以使代码更加简洁。
4. 静态内部类 (Static Nested Class)
静态内部类（也称为嵌套静态类）与前三种内部类有所不同，它不依赖于外部类的实例。
特点：
用 static 关键字修饰。不能直接访问外部类的非静态成员，只能访问外部类的静态成员。创建实例时不需要外部类的实例，可以直接通过 OuterClass.StaticInnerClass 访问。可以定义静态成员。
示例：
class OuterClass {
private static int staticOuterValue = 40;
private int nonStaticOuterValue = 50; // 静态内部类无法直接访问
static class StaticInnerClass { // 静态内部类
public void display() {
System.out.println("外部类的静态值: " + staticOuterValue);
// System.out.println(nonStaticOuterValue); // 错误：无法访问非静态成员
}
public static void staticMethod() {
System.out.println("静态内部类的静态方法");
}
}
public static void main(String[] args) {
// 创建静态内部类实例不需要外部类的实例
OuterClass.StaticInnerClass staticInner = new OuterClass.StaticInnerClass();
staticInner.display();
OuterClass.StaticInnerClass.staticMethod();
}
}
使用场景：
当内部类与外部类的实例没有逻辑关联，但又希望将它们在代码结构上组织在一起时。例如，构建器模式（Builder Pattern）中，通常会将 Builder 类定义为外部类的静态内部类。辅助工具类或常量定义，如 java.util.Map.Entry。
为什么使用内部类？
封装性增强： 内部类可以被隐藏在外部类中，实现更好的封装。外部类之外的代码无法直接访问内部类，除非通过外部类来暴露。代码组织和可读性： 将逻辑上相关的类组织在一起，使得代码结构更清晰，提高可读性和可维护性。访问外部类私有成员： 内部类可以直接访问外部类的所有成员，包括私有成员，这在某些设计中提供了极大的便利。解决多继承问题： Java 不支持多继承，但通过内部类，一个类可以实现多个接口，或者一个内部类继承一个类，而外部类继承另一个类，从而在某种程度上实现类似多继承的功能。实现回调机制： 匿名内部类在事件处理和回调函数中非常常用。
内部类对比概览
为了更直观地理解各种内部类的异同，我们整理了一个对比表格：
特性 / 内部类类型成员内部类 (Member Inner Class)局部内部类 (Local Inner Class)匿名内部类 (Anonymous Inner Class)静态内部类 (Static Nested Class)定义位置外部类的成员位置方法、构造器、代码块内部方法、构造器、代码块内部，在创建实例时定义外部类的成员位置，使用 static 修饰创建实例需外部类实例 outer.new Inner()仅在其定义的方法/块中创建在 new 表达式中创建，没有构造器不需要外部类实例 new Outer.Inner()命名有明确的类名有明确的类名没有类名有明确的类名访问修饰符可使用所有访问修饰符 (public, private 等)不可使用访问修饰符不可使用访问修饰符可使用所有访问修饰符访问外部类成员可访问外部类所有（包括 private）成员可访问外部类所有（包括 private）成员可访问外部类所有（包括 private）成员仅可访问外部类的 static 成员访问局部变量不可直接访问方法局部变量可访问 final 或有效 final 的局部变量可访问 final 或有效 final 的局部变量不可访问方法局部变量是否可定义 static 成员不可定义（除 final static 常量）不可定义不可定义可以定义 static 成员常见用途辅助外部类功能，迭代器局部辅助类，避免命名冲突事件监听器，回调，一次性实现Builder 模式，工具类，常量集合是否持有外部类引用是是是否
内部类与外部类的联系：编译器如何处理？
当你在 Java 中编译含有内部类的代码时，Java 编译器会做一些幕后工作。
成员内部类、局部内部类、匿名内部类： 编译器会生成独立的 .class 文件，其命名通常遵循 OuterClass$InnerClass.class、OuterClass$1LocalClass.class 或 OuterClass$1.class 这样的模式。为了让内部类能够访问外部类的成员（特别是私有成员），编译器会在编译时悄悄地在外部类中生成一些合成（Synthetic）方法来获取或设置这些私有成员。同时，非静态内部类的构造器会隐式地接收一个外部类实例的引用。
静态内部类： 静态内部类被视为一个独立的顶级类，只是其完全限定名包含了外部类。它不需要外部类的实例引用，因此其编译后的 .class 文件名通常是 OuterClass$StaticInnerClass.class。