Java非静态内部类是定义在另一个类内部且没有static修饰的类，它的实例创建和外围类实例存在强绑定关系，其多实例机制是理解内部类特性的核心内容。
非静态内部类的基本定义
非静态内部类属于外围类实例的成员，不能独立于外围类实例存在。它的定义格式如下：
// 外围类
public class OuterClass {
// 非静态内部类
public class InnerClass {
private int innerField;
public void innerMethod() {
System.out.println("这是非静态内部类的方法");
}
}
}
非静态内部类的多实例机制解析
实例创建的前提条件
非静态内部类的实例必须依附于一个已存在的外围类实例，不能直接通过外围类类名创建。创建语法有两种：
- 在外围类内部直接创建
- 在外围类外部通过外围类实例创建
多实例的创建示例
同一个外围类实例可以创建多个不同的非静态内部类实例，不同外围类实例创建的内部类实例也属于不同的实例，这就是多实例机制的核心体现。以下是具体代码示例：
public class OuterClass {
private String outerName;
public OuterClass(String outerName) {
this.outerName = outerName;
}
// 非静态内部类
public class InnerClass {
private int innerValue;
public InnerClass(int innerValue) {
this.innerValue = innerValue;
}
public void printInfo() {
System.out.println("外围类名称：" + outerName + "，内部类值：" + innerValue);
}
}
public static void main(String[] args) {
// 创建第一个外围类实例
OuterClass outer1 = new OuterClass("外围实例1");
// 基于outer1创建两个内部类实例
OuterClass.InnerClass inner1 = outer1.new InnerClass(10);
OuterClass.InnerClass inner2 = outer1.new InnerClass(20);
// 创建第二个外围类实例
OuterClass outer2 = new OuterClass("外围实例2");
// 基于outer2创建一个内部类实例
OuterClass.InnerClass inner3 = outer2.new InnerClass(30);
inner1.printInfo();
inner2.printInfo();
inner3.printInfo();
}
}
上述代码的运行结果为：
外围类名称：外围实例1，内部类值：10 外围类名称：外围实例1，内部类值：20 外围类名称：外围实例2，内部类值：30
可以看到，同一个外围类实例outer1可以创建inner1和inner2两个独立的非静态内部类实例，它们的innerValue属性互不影响。而outer2创建的inner3和前两个内部类实例也属于完全不同的实例，这就是非静态内部类的多实例特性。
多实例的内存逻辑
每个非静态内部类实例都会隐式持有一个指向创建它的外围类实例的引用，因此多个内部类实例如果来自同一个外围类实例，它们共享同一个外围类实例的引用，但内部类自身的成员变量是独立存储的。如果来自不同的外围类实例，那么内部类实例持有的外围类引用也不同。
非静态内部类的典型应用场景
场景1：需要访问外围类私有成员的场景
非静态内部类可以直接访问外围类的所有成员，包括private修饰的属性和方法，不需要通过getter/setter暴露外围类的内部状态。比如实现一个迭代器场景：
public class MyArrayList {
private Object[] elements;
private int size;
public MyArrayList(int capacity) {
elements = new Object[capacity];
size = 0;
}
public void add(Object obj) {
if (size < elements.length) {
elements[size] = obj;
size++;
}
}
// 非静态内部类实现迭代器
public class MyIterator {
private int cursor;
public MyIterator() {
cursor = 0;
}
public boolean hasNext() {
// 直接访问外围类的私有成员size
return cursor < size;
}
public Object next() {
if (cursor < size) {
// 直接访问外围类的私有成员elements
return elements[cursor++];
}
return null;
}
}
public MyIterator iterator() {
return new MyIterator();
}
}
场景2：逻辑上属于外围类的附属组件
当某个类的存在逻辑上完全依附于另一个类，且不需要独立于外围类存在时，适合定义为非静态内部类。比如事件监听器，通常事件监听器只服务于特定的组件实例，不同组件实例的监听器实例相互独立，符合多实例的特性。
// 模拟按钮类
public class Button {
private String label;
public Button(String label) {
this.label = label;
}
// 非静态内部类定义点击事件监听器
public class ClickListener {
public void onClick() {
System.out.println(label + "按钮被点击了");
}
}
public void simulateClick() {
ClickListener listener = new ClickListener();
listener.onClick();
}
}
场景3：需要多个独立实例且共享外围类上下文
如果某个业务需要多个独立的实例，且这些实例都需要共享同一个外围类的上下文信息，非静态内部类的多实例机制就非常合适。比如一个订单类下有多个订单项，每个订单项需要访问订单的公共信息（如订单编号、下单用户），此时订单项可以定义为非静态内部类。
使用注意事项
- 非静态内部类不能定义static成员（除了static final常量），因为非静态内部类依附于实例，static成员属于类级别，两者存在冲突。
- 避免非静态内部类持有外围类实例导致的内存泄漏，比如非静态内部类实例的生命周期长于外围类实例时，会造成外围类实例无法被回收。
- 如果不需要访问外围类的实例成员，优先考虑使用静态内部类，减少不必要的实例绑定开销。