Java非静态嵌套类是定义在另一个类内部且未使用static修饰的类，它的每个实例都和对应的外部类实例绑定，这种特性让它在多实例管理上有独特的要求和场景。非静态嵌套类可以直接访问外部类的成员变量和方法，在很多需要关联外部类状态的场景下非常实用。
非静态嵌套类的基础特性
非静态嵌套类的实例化必须基于外部类的实例，不能直接通过new 外部类.内部类()的方式创建。它的实例会隐式持有外部类实例的引用，这也是它可以直接访问外部类成员的原因。下面通过一个简单示例展示非静态嵌套类的定义和实例化：
// 外部类
public class OuterClass {
private String outerField = "外部类字段";
// 非静态嵌套类（内部类）
public class InnerClass {
public void printOuterField() {
// 直接访问外部类的私有字段
System.out.println(outerField);
}
}
public static void main(String[] args) {
// 先创建外部类实例
OuterClass outer = new OuterClass();
// 基于外部类实例创建内部类实例
OuterClass.InnerClass inner1 = outer.new InnerClass();
OuterClass.InnerClass inner2 = outer.new InnerClass();
inner1.printOuterField();
inner2.printOuterField();
}
}
非静态嵌套类多实例的管理方案
1. 实例存储管理
如果需要维护多个非静态嵌套类的实例，通常会使用集合类来存储这些实例。常见的存储方式包括使用<List>存储有序实例，使用<Map>关联实例和对应的标识。需要注意存储时要考虑实例的生命周期，避免不必要的引用导致内存无法释放。
import java.util.ArrayList;
import java.util.List;
public class OuterClass {
private String outerField = "外部类字段";
// 存储内部类实例的集合
private List<InnerClass> innerInstanceList = new ArrayList<>();
public class InnerClass {
private String innerId;
public InnerClass(String innerId) {
this.innerId = innerId;
}
public void printInfo() {
System.out.println("内部类ID：" + innerId + "，外部类字段：" + outerField);
}
}
// 创建并管理内部类实例的方法
public void addInnerInstance(String id) {
InnerClass inner = this.new InnerClass(id);
innerInstanceList.add(inner);
}
// 获取所有内部类实例
public List<InnerClass> getAllInnerInstances() {
return innerInstanceList;
}
public static void main(String[] args) {
OuterClass outer = new OuterClass();
outer.addInnerInstance("instance_1");
outer.addInnerInstance("instance_2");
for (OuterClass.InnerClass inner : outer.getAllInnerInstances()) {
inner.printInfo();
}
}
}
2. 实例生命周期控制
非静态嵌套类的实例持有外部类的引用，如果外部类实例需要被回收，但内部类实例还被其他对象引用，就会导致外部类实例也无法被回收，引发内存泄漏。因此管理多实例时需要及时移除不再使用的内部类实例，比如在集合中使用弱引用存储，或者在实例不再使用时主动从集合中删除。
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.List;
public class OuterClass {
private String outerField = "外部类字段";
// 使用弱引用存储内部类实例，避免内存泄漏
private List<WeakReference<InnerClass>> innerRefList = new ArrayList<>();
public class InnerClass {
private String innerId;
public InnerClass(String innerId) {
this.innerId = innerId;
}
}
public void addInnerInstance(String id) {
InnerClass inner = this.new InnerClass(id);
innerRefList.add(new WeakReference<>(inner));
}
public static void main(String[] args) {
OuterClass outer = new OuterClass();
outer.addInnerInstance("instance_1");
// 触发垃圾回收后，弱引用关联的内部类实例如果没有其他强引用会被回收
System.gc();
}
}
3. 实例间的状态同步
多个非静态嵌套类实例共享同一个外部类实例的状态，当外部类的状态发生变化时，所有内部类实例访问到的状态都会同步更新。如果需要在内部类实例之间同步自身状态，可以在内部类中维护共享状态，通过外部类作为中介进行传递。
import java.util.ArrayList;
import java.util.List;
public class OuterClass {
private String outerField = "初始值";
private List<InnerClass> innerList = new ArrayList<>();
public class InnerClass {
private String selfField;
public InnerClass(String selfField) {
this.selfField = selfField;
}
// 修改外部类状态，所有内部类实例都会感知到
public void updateOuterField(String newValue) {
outerField = newValue;
}
// 通知其他内部类实例更新自身状态
public void notifyOtherInners(String newSelfField) {
for (InnerClass inner : innerList) {
if (inner != this) {
inner.selfField = newSelfField;
}
}
}
}
public void addInner(InnerClass inner) {
innerList.add(inner);
}
}
非静态嵌套类多实例的应用场景
- 事件监听器场景：很多GUI框架中，每个组件的事件监听器可以定义为非静态嵌套类，多个监听器实例可以关联同一个外部容器类，方便访问容器的状态。
- 迭代器实现：集合类的迭代器通常作为非静态嵌套类实现，每个迭代器实例对应一个集合实例，迭代器可以直接访问集合的内部元素。
- 状态机实现：外部类作为状态机的上下文，多个非静态嵌套类实例作为不同的状态实现，每个状态实例可以访问上下文的当前状态和数据。
注意事项
首先要注意避免非静态嵌套类实例的滥用，因为每个实例都会持有外部类的引用，如果内部类实例生命周期远长于外部类，很容易造成内存泄漏。其次，序列化非静态嵌套类实例时，外部类的实例也会被一并序列化，需要确认是否符合业务需求。最后，非静态嵌套类不能定义静态成员（除了常量），如果需要静态成员可以考虑使用静态嵌套类。