内部类

Java 内部类详解：类型、特性与应用

内部类是定义在另一个类（外部类）中的类，作为外部类的一部分，它可以将逻辑相关的类组织在一起，并通过访问控制隐藏实现细节。内部类不仅能访问外部类的所有成员（包括私有成员），还能对其他类隐藏自身，是 Java 面向对象设计中灵活且强大的特性。

内部类的核心作用

1. 访问外部类私有成员：内部类可直接访问外部类的所有成员（包括 private 修饰的属性和方法），无需特殊权限。
2. 实现隐藏：内部类可被声明为 private 或 protected，仅外部类或其子类可见，对其他类隐藏。
3. 逻辑内聚：将仅被外部类使用的辅助类定义为内部类，增强代码的模块化和可读性。
4. 多实现灵活性：一个类可通过多个内部类实现同一接口的不同版本，解决单继承限制。

内部类的四种类型

根据定义位置和修饰符的不同，内部类分为四类：成员内部类、局部内部类、匿名内部类、静态内部类，各有不同的特性和适用场景。

成员内部类（Member Inner Class）

成员内部类是定义在外部类的成员位置（与属性、方法同级）的内部类，可视为外部类的 “成员变量”，具有以下特性：

核心特性：

• 依赖外部类实例：必须通过外部类实例才能创建成员内部类对象，无法独立存在。
• 访问权限修饰符：可被 public、protected、private 或默认修饰符修饰，控制其可见性。
• 无静态成员：成员内部类中不能定义静态属性、静态方法或静态内部类（编译报错）。
• 访问外部类成员：可直接访问外部类的所有成员（包括私有成员），通过隐式引用关联外部类实例。

代码示例：基本用法

public class Outer {
    private String outerField = "外部类私有属性"; // 外部类私有属性

    // 成员内部类（private修饰，仅外部类可见）
    private class Inner {
        public void accessOuter() {
            // 直接访问外部类私有属性
            System.out.println("访问外部类私有属性：" + outerField);
        }
    }

    // 外部类方法：创建内部类对象并调用其方法
    public void useInner() {
        Inner inner = new Inner(); // 外部类内部可直接创建内部类对象
        inner.accessOuter();
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.useInner(); // 输出：访问外部类私有属性：外部类私有属性

        // 外部类之外创建成员内部类对象（需通过外部类实例）
        Outer.Inner inner = outer.new Inner(); // 语法：外部类实例.new 内部类()
        inner.accessOuter();
    }
}

关键细节：外部类引用与 .this 语法

成员内部类对象会隐式持有外部类实例的引用，因此能访问外部类成员。若需显式获取外部类实例，可使用 外部类名.this：

public class Outer {
    private String name = "Outer";

    class Inner {
        private String name = "Inner";

        public void printName() {
            System.out.println("内部类name：" + name); // 访问内部类自身属性
            System.out.println("外部类name：" + Outer.this.name); // 显式访问外部类属性
        }
    }

    public static void main(String[] args) {
        new Outer().new Inner().printName();
        // 输出：
        // 内部类name：Inner
        // 外部类name：Outer
    }
}

• 编译验证：通过javap反编译内部类字节码（Outer$Inner.class），可发现其构造器需传入外部类实例，证明隐式引用的存在：

javap -c Outer$Inner
# 输出构造器包含外部类参数：(LOuter;)V

局部内部类（Local Inner Class）

局部内部类是定义在方法或代码块中的内部类，可视为 “局部变量”，具有以下特性：

核心特性：

• 无访问修饰符：局部内部类不能被 public、private 等修饰符修饰（类似局部变量）。
• 作用域限制：仅在定义它的方法或代码块内可见，出了作用域无法访问。
• 访问局部变量限制：局部内部类访问外部方法的局部变量时，该变量必须是 final 或有效 final（Java 8+ 后 “有效 final” 指变量赋值后未被修改）。
• 无静态成员：同成员内部类，不能定义静态属性或方法。

代码示例：方法中的局部内部类

public class MethodOuter {
    // 外部类方法
    public void createLocalInner(String prefix) {
        // 局部变量（有效final：赋值后未修改）
        String suffix = "!"; 

        // 局部内部类（仅在createLocalInner方法内可见）
        class LocalInner {
            public void print() {
                // 访问外部方法的局部变量（必须是final或有效final）
                System.out.println(prefix + suffix); 
            }
        }

        // 方法内创建局部内部类对象并使用
        new LocalInner().print();
    }

    public static void main(String[] args) {
        MethodOuter outer = new MethodOuter();
        outer.createLocalInner("Hello"); // 输出：Hello!
    }
}

为什么局部变量需要 final？

局部变量的生命周期与方法同步（方法执行结束后销毁），而局部内部类对象可能通过闭包逃逸出方法（如作为返回值）。若局部变量可修改，内部类对象引用的变量值可能已失效，导致逻辑混乱。final 保证变量值不可变，即使变量销毁，内部类也能持有其常量值。

匿名内部类（Anonymous Inner Class）

匿名内部类是没有类名的内部类，通常用于快速实现接口或继承类，仅在创建时使用一次，语法上直接通过 new 父类/接口() 定义。

核心特性：

• 无类名：无法通过类名引用，只能在创建时使用。
• 单继承 / 单实现：只能继承一个类或实现一个接口。
• 无构造器：因无类名，不能定义构造器，可通过初始化块完成初始化。
• 隐式 final：若访问外部局部变量，同样要求变量为 final 或有效 final。

代码示例：实现接口的匿名内部类

// 定义接口
interface Greeting {
    void sayHello();
}

public class AnonymousDemo {
    public Greeting getGreeting(String name) {
        // 返回匿名内部类（实现Greeting接口）
        return new Greeting() {
            // 初始化块（替代构造器）
            {
                System.out.println("匿名内部类初始化：" + name);
            }

            @Override
            public void sayHello() {
                System.out.println("Hello, " + name);
            }
        };
    }

    public static void main(String[] args) {
        AnonymousDemo demo = new AnonymousDemo();
        Greeting greeting = demo.getGreeting("Alice");
        greeting.sayHello(); // 输出：匿名内部类初始化：Alice → Hello, Alice
    }
}

常见应用场景：

• 简化事件监听器（如 Swing 中的 ActionListener）。

• 快速实现临时使用的接口（如排序的Comparator）。

  // 示例：使用匿名内部类作为Comparator
  import java.util.Arrays;
  import java.util.Comparator;
  
  public class AnonComparator {
      public static void main(String[] args) {
          String[] names = {"Bob", "Alice", "Charlie"};
          // 匿名内部类实现Comparator接口
          Arrays.sort(names, new Comparator<String>() {
              @Override
              public int compare(String s1, String s2) {
                  return s1.length() - s2.length(); // 按长度排序
              }
          });
          System.out.println(Arrays.toString(names)); // 输出：[Bob, Alice, Charlie]
      }
  }

静态内部类（Static Nested Class）

静态内部类是用 static 修饰的内部类，可视为外部类的 “静态成员”，与其他内部类的最大区别是不依赖外部类实例。

核心特性：

• 独立存在：创建静态内部类对象无需外部类实例，直接通过 外部类名.内部类名 访问。
• 访问限制：只能访问外部类的 静态成员（包括静态私有成员），不能访问非静态成员。
• 可包含静态成员：静态内部类中可定义静态属性、静态方法和静态内部类（其他内部类不行）。
• 接口中的内部类：接口中的内部类默认是 static 的（无需显式声明），且默认为 public。

代码示例：静态内部类的基本用法

public class StaticOuter {
    private static String staticField = "外部类静态属性";
    private String nonStaticField = "外部类非静态属性";

    // 静态内部类
    public static class StaticInner {
        private static int count = 0; // 允许定义静态属性

        public void accessOuter() {
            // 可访问外部类静态成员
            System.out.println("访问外部类静态属性：" + staticField);

            // 不能访问外部类非静态成员（编译报错）
            // System.out.println(nonStaticField); 
        }

        public static void staticMethod() { // 允许定义静态方法
            System.out.println("静态内部类静态方法，count：" + (count++));
        }
    }

    public static void main(String[] args) {
        // 无需外部类实例，直接创建静态内部类对象
        StaticOuter.StaticInner inner = new StaticOuter.StaticInner();
        inner.accessOuter(); // 输出：访问外部类静态属性：外部类静态属性

        // 直接调用静态内部类的静态方法
        StaticOuter.StaticInner.staticMethod(); // 输出：静态内部类静态方法，count：0
    }
}

接口中的内部类（默认静态）

public interface MyInterface {
    // 接口中的内部类默认是public static
    class InnerClass {
        public void doSomething() {
            System.out.println("接口中的静态内部类");
        }
    }
}

// 使用接口中的内部类
public class TestInterfaceInner {
    public static void main(String[] args) {
        MyInterface.InnerClass inner = new MyInterface.InnerClass();
        inner.doSomething(); // 输出：接口中的静态内部类
    }
}

四种内部类的核心区别

特性	成员内部类	局部内部类	匿名内部类	静态内部类
定义位置	外部类成员位置	方法 / 代码块内	方法 / 代码块内（创建时）	外部类成员位置
访问修饰符	可被 public/private 等修饰	无（类似局部变量）	无	可被 public/private 等修饰
依赖外部类实例	是（必须通过外部类实例创建）	是（隐含外部类引用）	是（隐含外部类引用）	否（独立创建）
访问外部类成员	所有成员（静态 + 非静态）	所有成员（静态 + 非静态）	所有成员（静态 + 非静态）	仅静态成员
包含静态成员	否	否	否	是
类名	有	有	无	有
典型使用场景	外部类的辅助类，需访问非静态成员	方法内临时使用的辅助类	快速实现接口 / 继承类（单次使用）	独立于外部类的工具类，仅依赖静态成员

内部类的实际应用场景

1. 迭代器模式：集合类（如 ArrayList）的 Iterator 通常定义为内部类，可直接访问集合的私有数组。
2. 工厂模式：外部类通过多个内部类实现同一接口，提供不同版本的产品。
3. 事件处理：GUI 编程中，匿名内部类常用于简化事件监听器的实现（如按钮点击事件）。
4. 隐藏实现细节：将工具类定义为 private 成员内部类，仅外部类可使用，对外隐藏逻辑