一、内部类的基础概念与分类
内部类（Inner Class）是 Java 语言中一个强大的特性，它允许在一个类的内部定义另一个类。这种嵌套关系不仅仅是语法上的组织形式，更带来了诸多优势：
- 增强封装性：内部类可以访问外部类的私有成员，同时自身也可以对外隐藏实现细节
- 命名空间控制：内部类可以避免命名冲突，使代码结构更清晰
- 代码组织：将逻辑相关的类组织在一起，提高代码的可读性和可维护性
- 回调机制实现：常用于实现事件监听器等回调机制
内部类分类
Java 内部类根据定义方式和特性的不同，可分为四大类：
1. 成员内部类（Member Inner Class）
成员内部类是直接定义在外部类成员位置的内部类，具有以下特点：
public class Outer {
private String outerField = "外部类字段";
// 成员内部类
class Inner {
void accessOuter() {
System.out.println(outerField); // 可以访问外部类的私有成员
}
}
}
- 可以访问外部类的所有成员（包括 private）
- 不能有静态成员（除非是常量）
- 必须先创建外部类实例才能创建成员内部类实例
2. 局部内部类（Local Inner Class）
局部内部类是定义在方法或代码块中的内部类：
public class Outer {
public void someMethod() {
final String localVar = "局部变量";
// 局部内部类
class LocalInner {
void print() {
System.out.println("访问局部变量：" + localVar);
}
}
new LocalInner().print();
}
}
- 只在定义它的方法或代码块中可见
- 可以访问方法中的 final 局部变量
- 不能使用访问修饰符（public/private/protected）
3. 静态内部类（Static Nested Class）
静态内部类是使用 static 修饰的内部类：
public class Outer {
private static String staticField = "静态字段";
// 静态内部类
static class StaticNested {
void accessOuter() {
System.out.println(staticField); // 只能访问外部类的静态成员
}
}
}
- 不持有外部类的引用
- 可以访问外部类的静态成员
- 可以被实例化而无需外部类实例
- 可以有自己的静态成员
4. 匿名内部类（Anonymous Inner Class）
匿名内部类是没有类名的内部类，通常用于快速实现接口或继承类：
public interface Greeting {
void greet();
}
public class Test {
public static void main(String[] args) {
// 匿名内部类
Greeting greeting = new Greeting() {
@Override
public void greet() {
System.out.println("Hello, world!");
}
};
greeting.greet();
}
}
- 没有类名，直接实例化
- 常用于事件处理器、线程实现等场景
- 只能访问 final 局部变量
- 语法简洁但可读性可能较差
应用场景
内部类在以下场景中特别有用：
- GUI 编程：用于事件监听器的实现
- 集合框架：如 Map.Entry 的实现
- 回调机制：实现观察者模式
- 私有实现：隐藏类实现细节
- 辅助类：为外部类提供特定功能的辅助类
二、成员内部类详解
1. 成员内部类概述
成员内部类是最基础的内部类形式，它如同外部类的一个普通成员，可以访问外部类的所有成员（包括 private 成员），而外部类也可以通过内部类的实例访问内部类的成员。成员内部类与普通成员变量类似，只是它定义的是一个类而非变量。
典型应用场景：
- 当需要将两个密切相关的类紧密绑定在一起时
- 当内部类需要直接访问外部类的私有成员时
- 实现事件监听器模式（如GUI编程中的事件处理）
2. 成员内部类的定义与实例化
2.1 基本定义语法
public class OuterClass {
private String outerField = "外部类字段";
// 定义成员内部类
public class InnerClass {
private String innerField = "内部类字段";
public void innerMethod() {
System.out.println("访问外部类字段：" + outerField);
System.out.println("访问内部类字段：" + innerField);
}
}
// 外部类中使用内部类
public void outerMethod() {
InnerClass inner = new InnerClass();
inner.innerMethod();
}
public static void main(String[] args) {
// 外部类之外创建内部类实例
OuterClass outer = new OuterClass();
OuterClass.InnerClass inner = outer.new InnerClass();
inner.innerMethod();
}
}
2.2 实例化方式详解
-
在外部类内部实例化：
InnerClass inner = new InnerClass(); // 直接实例化 -
在外部类外部实例化：
OuterClass outer = new OuterClass(); OuterClass.InnerClass inner = outer.new InnerClass(); -
在静态方法中实例化：
public static void staticMethod() { OuterClass outer = new OuterClass(); InnerClass inner = outer.new InnerClass(); }
2.3 注意事项
-
static成员限制：
- 成员内部类不能定义 static 成员（包括 static 字段、static 方法和静态内部类）
- 例外：static final 常量是允许的
-
实例化依赖：
- 实例化成员内部类必须依赖外部类实例
- 使用
外部类实例.new 内部类()语法
-
访问权限：
- 成员内部类可以访问外部类的所有成员，包括 private 修饰的成员
- 外部类也可以通过内部类实例访问内部类的成员（包括私有成员）
-
编译后文件：
- 编译后会生成
OuterClass$InnerClass.class文件
- 编译后会生成
3. 成员内部类与外部类的相互访问
3.1 常规访问
public class OuterClass {
private int outerVar = 10;
public class InnerClass {
private int innerVar = 20;
public void show() {
System.out.println("外部类变量: " + outerVar); // 直接访问外部类变量
System.out.println("内部类变量: " + innerVar);
}
}
public void display() {
InnerClass inner = new InnerClass();
System.out.println("内部类变量: " + inner.innerVar); // 外部类访问内部类变量
inner.show();
}
}
3.2 同名成员的访问
当内部类与外部类存在同名成员时，访问外部类成员需要使用外部类名.this.成员名的语法：
public class OuterClass {
private String name = "Outer";
public class InnerClass {
private String name = "Inner";
public void printName() {
String name = "Local";
System.out.println(name); // 局部变量：Local
System.out.println(this.name); // 内部类成员：Inner
System.out.println(OuterClass.this.name); // 外部类成员：Outer
}
}
}
3.3 实际应用示例
// 汽车引擎示例
public class Car {
private String model;
private Engine engine;
public Car(String model) {
this.model = model;
this.engine = new Engine();
}
// 成员内部类
public class Engine {
private int horsepower;
public void setHorsepower(int hp) {
this.horsepower = hp;
System.out.println(model + "的引擎马力设置为：" + hp); // 直接访问外部类字段
}
public void start() {
System.out.println(model + "的" + horsepower + "马力引擎启动");
}
}
public void drive() {
engine.start();
System.out.println(model + "正在行驶...");
}
public static void main(String[] args) {
Car myCar = new Car("Tesla Model S");
Car.Engine engine = myCar.new Engine();
engine.setHorsepower(500);
myCar.drive();
}
}
三、静态内部类详解
静态内部类是使用 static 修饰的内部类，它与外部类的关系相对独立，更像是一个独立的类，只是定义在外部类的命名空间中。
代码示例
public class OuterClass {
// 外部类静态字段
private static String staticField = "外部类静态字段";
// 外部类实例字段
private String instanceField = "外部类实例字段";
// 静态内部类
public static class StaticInnerClass {
// 静态内部类的静态字段
private static String innerStaticField = "内部类静态字段";
// 静态内部类的实例字段
private String innerInstanceField = "内部类实例字段";
// 实例方法
public void innerMethod() {
// 可以访问外部类的静态成员
System.out.println(staticField);
// 不能直接访问外部类的实例成员
// System.out.println(instanceField); // 编译错误
// 访问内部类自己的成员
System.out.println(innerStaticField);
System.out.println(innerInstanceField);
}
// 静态方法
public static void innerStaticMethod() {
System.out.println("内部类静态方法");
}
}
public static void main(String[] args) {
// 实例化静态内部类，不需要外部类实例
OuterClass.StaticInnerClass inner = new OuterClass.StaticInnerClass();
inner.innerMethod();
// 调用静态内部类的静态方法
OuterClass.StaticInnerClass.innerStaticMethod();
}
}
核心特性
-
静态成员定义：
- 静态内部类可以定义
static成员（包括静态字段和静态方法），这是与成员内部类的重要区别 - 例如代码中的
innerStaticField和innerStaticMethod()
- 静态内部类可以定义
-
访问权限：
- 静态内部类只能访问外部类的
static成员（如代码中的staticField） - 不能直接访问外部类的实例成员（如
instanceField会报编译错误） - 如果需要访问外部类的实例成员，必须通过外部类的实例来访问
- 静态内部类只能访问外部类的
-
实例化方式：
- 实例化静态内部类不需要外部类实例
- 直接使用
外部类名.内部类名()语法（如new OuterClass.StaticInnerClass()）
-
独立性：
- 静态内部类与外部类的实例无关
- 相当于一个独立的类，只是定义在外部类的命名空间中
- 可以独立存在和使用，不需要依赖外部类实例
静态内部类的适用场景
静态内部类通常用于以下场景：
-
辅助类实现：
- 当内部类与外部类的联系不紧密，不需要访问外部类实例成员时
- 作为外部类的辅助类，仅为外部类服务，又希望避免全局可见
-
Builder模式：
- 实现 Builder 模式的经典应用
- 例如 Android 中的
AlertDialog.Builder就是典型的静态内部类应用 - 示例代码：
public class AlertDialog { private String title; private String message; private AlertDialog(Builder builder) { this.title = builder.title; this.message = builder.message; } public static class Builder { private String title; private String message; public Builder setTitle(String title) { this.title = title; return this; } public Builder setMessage(String message) { this.message = message; return this; } public AlertDialog build() { return new AlertDialog(this); } } }
-
工具类封装：
- 将相关工具类封装在外部类内部
- 例如数学计算中的常量和方法可以封装在静态内部类中
-
事件监听器：
- 当需要实现事件监听器但又不需要访问外部类实例时
- 可以避免创建不必要的外部类实例引用
-
测试类：
- 在单元测试中，可以将测试类作为被测类的静态内部类
- 保持测试代码与被测代码的紧密关系
四、局部内部类详解
局部内部类是定义在方法体或代码块中的内部类，它的作用域仅限于所在的方法或代码块。这种类设计的主要目的是为了将类的使用限制在特定的上下文环境中，提高代码的封装性和安全性。
4.1 局部内部类的定义与使用
public class OuterClass {
// 外部类字段
private String outerField = "外部类字段";
// 外部类方法
public void outerMethod(final int param) {
// 方法局部变量（必须是final或effectively final）
final String localVar = "局部变量";
// 局部内部类定义
class LocalInnerClass {
// 内部类字段
private String innerField = "局部内部类字段";
// 内部类方法
public void innerMethod() {
// 可以访问外部类成员
System.out.println("访问外部类字段：" + outerField);
// 可以访问方法参数
System.out.println("访问方法参数：" + param);
// 可以访问局部变量
System.out.println("访问局部变量：" + localVar);
// 访问内部类自己的成员
System.out.println("访问内部类字段：" + innerField);
}
}
// 在方法内部创建并使用局部内部类实例
LocalInnerClass inner = new LocalInnerClass();
inner.innerMethod();
}
public static void main(String[] args) {
OuterClass outer = new OuterClass();
outer.outerMethod(100);
}
}
关键特性详解：
-
作用域限制：
- 局部内部类仅能在定义它的方法或代码块中使用
- 例如：如果在
outerMethod中定义的LocalInnerClass，在main方法中就无法访问
-
访问权限：
- 不能使用public、private、protected等访问修饰符
- 因为它的可见性已经被限制在方法内部
-
访问外部成员：
- 可以访问外部类的所有成员（包括private成员）
- 示例中展示了访问
outerField私有字段
-
访问局部变量：
- Java 8之前：必须显式声明为final的局部变量
- Java 8之后：支持effectively final变量（即初始化后不再修改的变量）
- 示例中的
param和localVar都符合这个要求
4.2 局部内部类的注意事项
-
使用限制：
- 只能在定义它的方法内部实例化
- 不能在方法外部创建该类的实例
- 不能在其他方法中引用同一个局部内部类
-
变量访问规则：
- 经典示例：
public void method() { int x = 10; // effectively final int y = 20; y = 30; // 修改后不再是effectively final class Local { void print() { System.out.println(x); // 允许 // System.out.println(y); // 编译错误 } } }
- 经典示例：
-
静态成员限制：
- 不能声明static成员（字段或方法）
- 因为局部内部类本身与实例相关
-
命名规则：
- 同一个类中不同方法可以定义同名的局部内部类
- 这些类是相互独立的，不会产生冲突
- 示例：
public class Test { void method1() { class SameName {} } void method2() { class SameName {} // 允许 } }
-
实际应用场景：
- Swing/AWT事件处理
- 需要临时使用的特殊实现
- 需要访问方法局部变量的回调场景
五、匿名内部类详解
匿名内部类是一种没有类名的特殊内部类，通常用于快速创建一个实现了某个接口或继承了某个类的实例，简化代码编写。它特别适用于只需要使用一次的类实现，避免了为简单功能创建单独类文件的繁琐。
5.1 匿名内部类的基本语法
匿名内部类的语法格式如下：
new 父类/接口() {
// 匿名内部类的实现代码
};
常见使用场景
1. 实现接口
public interface Greeting {
void sayHello();
}
public class AnonymousDemo {
public static void main(String[] args) {
// 创建实现Greeting接口的匿名内部类
Greeting greeting = new Greeting() {
@Override
public void sayHello() {
System.out.println("Hello, Anonymous Inner Class!");
// 可以添加更多实现细节
System.out.println("This is a detailed implementation.");
}
};
greeting.sayHello();
}
}
2. 继承类
public abstract class Animal {
public abstract void makeSound();
public void eat() {
System.out.println("Animal is eating...");
}
}
public class AnonymousDemo {
public static void main(String[] args) {
// 创建继承Animal类的匿名内部类
Animal cat = new Animal() {
@Override
public void makeSound() {
System.out.println("Meow~");
// 可以调用父类方法
eat();
}
// 可以添加新的方法
public void purr() {
System.out.println("Purrr...");
}
};
cat.makeSound();
// cat.purr(); // 编译错误，因为Animal类没有purr方法
}
}
3. 作为方法参数
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
public class ButtonDemo {
public static void main(String[] args) {
JFrame frame = new JFrame("Button Demo");
JButton button = new JButton("Click Me");
// 匿名内部类作为方法参数
button.addActionListener(new ActionListener() {
private int clickCount = 0; // 可以定义成员变量
@Override
public void actionPerformed(ActionEvent e) {
clickCount++;
System.out.println("Button clicked " + clickCount + " times!");
if (clickCount > 3) {
System.out.println("That's enough clicking!");
}
}
});
frame.add(button);
frame.setSize(300, 200);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
}
5.2 匿名内部类的特性与限制
特性：
- 匿名性：匿名内部类没有类名，无法直接实例化，只能在创建时使用一次
- 继承/实现限制：必须继承一个父类或实现一个接口，且只能继承一个类或实现一个接口
- 访问权限：可以访问外部类的成员，包括private成员
- 局部变量访问：可以访问所在方法的final或effectively final的局部变量
- 成员定义：可以定义自己的成员变量和方法（但外部无法访问非继承的方法）
限制：
- 构造方法：不能定义构造方法（因为没有类名）
- 抽象性：不能是抽象类（必须实现父类或接口的所有抽象方法）
- 修饰符限制：不能使用访问修饰符（public/protected/private）、static修饰
- 静态成员：不能定义static成员和static方法
- 可读性：复杂的匿名内部类可能降低代码可读性
5.3 匿名内部类与 Lambda 表达式
在 Java 8 引入 Lambda 表达式后，许多匿名内部类的使用场景可以被 Lambda 表达式替代，使代码更简洁：
// 匿名内部类方式
Runnable runnable1 = new Runnable() {
@Override
public void run() {
System.out.println("Running with anonymous class");
System.out.println("Current time: " + System.currentTimeMillis());
}
};
// Lambda表达式方式（更简洁）
Runnable runnable2 = () -> {
System.out.println("Running with lambda");
System.out.println("Current time: " + System.currentTimeMillis());
};
new Thread(runnable1).start();
new Thread(runnable2).start();
注意事项：
- Lambda 表达式仅适用于函数式接口（只有一个抽象方法的接口）
- 当需要访问外部类的非final实例变量或需要定义自己的状态时，仍需使用匿名内部类
- 当接口有多个方法时，必须使用匿名内部类
- 需要覆盖父类方法时（不仅是实现接口方法），必须使用匿名内部类
六、内部类的实际应用场景
6.1 封装与信息隐藏
内部类可以被声明为 private，只允许外部类访问，实现了更好的封装。这种封装方式特别适用于数据结构实现，如链表、树等，可以隐藏内部节点的实现细节。
public class DataStructure {
// 私有内部类，对外完全隐藏
private class Node {
int data;
Node next;
// 构造方法初始化节点数据
Node(int data) {
this.data = data;
this.next = null;
}
// 节点数据获取方法
int getData() {
return this.data;
}
}
private Node head;
private int size;
// 外部类提供公共方法操作内部类
public void add(int data) {
Node newNode = new Node(data);
if(head == null) {
head = newNode;
} else {
Node current = head;
while(current.next != null) {
current = current.next;
}
current.next = newNode;
}
size++;
}
// 获取链表大小
public int size() {
return size;
}
}
6.2 实现多重继承效果
Java 不支持类的多重继承，但通过内部类可以间接实现类似效果。这在需要组合多个类功能时特别有用。
// 父类A提供方法A
class A {
void methodA() {
System.out.println("A's method executing...");
}
}
// 父类B提供方法B
class B {
void methodB() {
System.out.println("B's method executing...");
}
}
public class C {
// 内部类继承A
class InnerA extends A {
void callMethodA() {
methodA();
}
}
// 内部类继承B
class InnerB extends B {
void callMethodB() {
methodB();
}
}
// 测试方法
public void test() {
System.out.println("Calling methods through inner classes:");
new InnerA().callMethodA();
new InnerB().callMethodB();
}
public static void main(String[] args) {
C c = new C();
c.test();
}
}
6.3 事件监听器与回调机制
在 GUI 编程中，匿名内部类广泛用于事件监听，简化了事件处理代码的组织。
import javax.swing.*;
import java.awt.event.*;
public class ButtonExample {
public static void main(String[] args) {
JFrame frame = new JFrame("Button Example");
JButton button = new JButton("Click Me");
// 使用匿名内部类实现ActionListener
button.addActionListener(new ActionListener() {
private int clickCount = 0;
@Override
public void actionPerformed(ActionEvent e) {
clickCount++;
System.out.println("Button clicked " + clickCount + " times");
// 可以访问外部类的final变量
if(clickCount == 3) {
button.setText("Enough clicks!");
}
}
});
frame.add(button);
frame.setSize(300, 200);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
}
6.4 构建器模式（Builder Pattern）
静态内部类常被用于实现构建器模式，简化复杂对象的创建过程，特别适用于具有多个可选参数的类。
public class Computer {
// 必选参数
private final String cpu;
// 可选参数
private final String memory;
private final String disk;
private final String gpu;
private final int usbPorts;
// 私有构造方法，只能通过Builder创建实例
private Computer(Builder builder) {
this.cpu = builder.cpu;
this.memory = builder.memory;
this.disk = builder.disk;
this.gpu = builder.gpu;
this.usbPorts = builder.usbPorts;
}
// 静态内部类实现Builder
public static class Builder {
// 必选参数
private final String cpu;
// 可选参数 - 提供默认值
private String memory = "8GB";
private String disk = "256GB SSD";
private String gpu = "Integrated";
private int usbPorts = 2;
// Builder构造方法必须包含必选参数
public Builder(String cpu) {
this.cpu = cpu;
}
// 设置可选参数的方法，返回Builder实现链式调用
public Builder memory(String memory) {
this.memory = memory;
return this;
}
public Builder disk(String disk) {
this.disk = disk;
return this;
}
public Builder gpu(String gpu) {
this.gpu = gpu;
return this;
}
public Builder usbPorts(int usbPorts) {
this.usbPorts = usbPorts;
return this;
}
// build方法创建Computer实例
public Computer build() {
return new Computer(this);
}
}
// 使用方式
public static void main(String[] args) {
// 创建配置好的Computer实例
Computer gamingComputer = new Computer.Builder("Intel i9")
.memory("32GB")
.disk("1TB NVMe SSD")
.gpu("NVIDIA RTX 3080")
.usbPorts(4)
.build();
Computer officeComputer = new Computer.Builder("Intel i5")
.memory("16GB")
.build();
}
}
七、内部类的注意事项与最佳实践
7.1 内存泄漏风险及解决方案
内部类（尤其是非静态内部类）会隐式持有外部类的引用，这在某些情况下可能导致内存泄漏问题。这是因为在Java中，非静态内部类会自动持有其外部类实例的引用，这种隐式引用关系可能造成意外的对象生命周期延长。
典型内存泄漏场景示例
public class Outer {
public Inner inner;
public void createInner() {
inner = new Inner(); // 创建内部类实例
}
public class Inner {
// 内部类隐式持有Outer实例的引用
void doSomething() {
System.out.println("Accessing outer class");
}
}
}
// 使用场景
Outer outer = new Outer();
outer.createInner();
// 即使outer不再被使用，但由于inner仍持有引用，outer无法被GC回收
解决方案建议
1.使用静态内部类：
-
- 当内部类生命周期可能长于外部类时，优先考虑使用静态内部类
- 静态内部类不会隐式持有外部类实例的引用
public class Outer {
public static class StaticInner {
// 静态内部类不会持有外部类实例的引用
}
}
2.及时释放引用：
3.使用弱引用：
- 在不需要内部类实例时，显式地将其引用置为null
- 特别注意Activity/Fragment等Android组件中的Handler使用
- 对于必须使用非静态内部类且需要避免内存泄漏的场景，可以考虑使用WeakReference
7.2 序列化问题及处理方案
非静态内部类在序列化时存在特殊问题，因为它们隐式包含对外部类实例的引用。当序列化非静态内部类时，Java会尝试同时序列化外部类实例，这可能导致以下问题：
- 外部类可能未实现Serializable接口，导致序列化失败
- 即使外部类可序列化，也可能导致意外地序列化了大量不必要的数据
- 反序列化时可能破坏原有的对象关系
解决方案
-
优先使用静态内部类：
public class Outer { public static class SerializableInner implements Serializable { // 可安全序列化的静态内部类 } } -
如果必须使用非静态内部类：
- 确保外部类也实现Serializable
- 考虑使用transient修饰不需要序列化的字段
- 实现自定义的序列化逻辑（writeObject/readObject）
7.3 代码可读性优化建议
内部类虽然提供了封装便利，但过度使用会降低代码可读性和维护性。以下是使用建议：
适用场景
- 当内部类代码较短（通常不超过50行）且只服务于外部类时
- 需要访问外部类私有成员的特殊场景
- 实现事件监听器等简单回调逻辑
不适用场景
- 内部类代码逻辑复杂或较长时
- 该功能可能被多个类复用时
- 需要独立测试的组件
重构示例
// 重构前 - 过长的内部类
public class OrderProcessor {
private class PaymentHandler {
// 200行处理支付的代码...
}
}
// 重构后 - 独立类
public class PaymentHandler {
// 独立的支付处理类
}
public class OrderProcessor {
private PaymentHandler paymentHandler;
}
7.4 访问权限控制最佳实践
合理控制内部类的访问权限可以更好地封装实现细节：
-
private内部类：
- 仅限外部类内部使用
- 完全隐藏实现细节
public class Database { private class ConnectionPool { // 仅Database可访问 } } -
包级(default)内部类：
- 同一包中的类可以访问
- 适合组件内部协作
-
protected/public内部类：
- 谨慎使用，确保确实需要对外暴露
- 通常配合接口使用，隐藏具体实现
-
嵌套层级控制：
- 避免多层嵌套内部类（如内部类中包含内部类）
- 嵌套层级建议不超过2层
八、内部类常见面试题解析
1.Q：成员内部类与静态内部类的区别？
A：成员内部类必须依赖外部类实例存在，可以访问外部类的所有成员（包括 private 成员），因为它隐式持有一个指向外部类实例的引用。例如：
class Outer {
private int outerField;
class Inner {
void access() {
System.out.println(outerField); // 可直接访问外部类私有成员
}
}
}
静态内部类不依赖外部类实例，只能访问外部类的静态成员。它可以有自己的静态成员，常用于工具类或辅助类。例如：
class Outer {
private static int staticOuterField;
static class StaticInner {
static void access() {
System.out.println(staticOuterField); // 只能访问外部类静态成员
}
}
}
2.Q：匿名内部类为什么只能访问 final 变量？
A：这涉及到 Java 的变量捕获机制。匿名内部类可能被延迟执行（如事件监听器），而它所访问的方法局部变量在方法执行完毕后会被销毁。例如：
void someMethod() {
final int count = 10; // 必须声明为 final
new Thread(new Runnable() {
public void run() {
System.out.println(count); // 捕获的变量
}
}).start();
}
从 Java 8 开始，可以省略 final 关键字（实际上是"effectively final"），但变量仍然必须保持不可变特性。这是为了保证内部类访问的变量值与创建时捕获的值一致，避免潜在的并发问题。
3.Q：内部类的 class 文件命名规则是什么？
A：Java 编译器会为内部类生成独立的 class 文件，命名规则如下：
- 普通成员内部类：OuterClass$InnerClass.class
- 静态内部类：OuterClass$StaticInnerClass.class
- 匿名内部类：OuterClass$1.class（按出现顺序编号）
- 方法内部类：OuterClass$1MethodName$InnerClass.class
例如：
class Outer {
class Inner {}
static class StaticInner {}
void method() {
new Object() {}; // 匿名内部类
}
}
编译后会生成：
- Outer.class
- Outer$Inner.class
- Outer$StaticInner.class
- Outer$1.class（匿名内部类）
4.Q：如何理解内部类的访问权限？
A：内部类的访问权限涉及两个方向：
1.内部类访问外部类：
2.外部类访问内部类：
- 可以自由访问外部类的所有成员（包括 private）
- 成员内部类通过隐式的 OuterClass.this 引用外部类实例
- 静态内部类只能访问外部类的静态成员
- 必须通过实例访问（静态内部类的静态成员除外）
- 可以访问任何可见性修饰的内部类成员
- 需要通过 new 关键字创建内部类实例
例如：
class Outer {
private int x = 10;
class Inner {
private int y = 20;
void show() {
System.out.println(x); // 直接访问外部类私有成员
}
}
void test() {
Inner inner = new Inner();
System.out.println(inner.y); // 通过实例访问内部类私有成员
}
}
扫一扫
171万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
