问：关于内部类，知道这些就够了~

内部类是一种强大的特性，允许我们在一个类的定义中嵌套另一个类的定义。内部类提供了更好的封装性，可以将逻辑上相关的类组织在一起，并且可以直接访问外部类的成员。

一、成员内部类

成员内部类是定义在外部类中的非静态类。作为外部类的一个成员，它可以无条件地访问外部类的所有成员变量和方法，包括私有的。成员内部类依赖于外部类的实例，因此在创建成员内部类的实例之前，必须先存在外部类的实例。

代码示例：

public class OuterClass {
    private int outerVariable = 10;

    class MemberInnerClass {
        void accessOuterMembers() {
            System.out.println("Outer variable: " + outerVariable);
        }
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        // 创建成员内部类的实例需要通过外部类实例来引用
        OuterClass.MemberInnerClass inner = outer.new MemberInnerClass();
        inner.accessOuterMembers(); // 输出：Outer variable: 10
    }
}

二、静态内部类

静态内部类是定义在外部类中的静态类。与成员内部类不同，静态内部类不依赖于外部类的实例。因此，它不能直接访问外部类的非静态成员，只能访问静态成员。静态内部类的创建无需外部类实例，可以直接通过类名来引用。

代码示例：

public class OuterClass {
    private static int outerStaticVariable = 20;

    static class StaticInnerClass {
        void accessOuterMembers() {
            System.out.println("Outer static variable: " + outerStaticVariable);
        }
    }

    public static void main(String[] args) {
        // 静态内部类可以直接通过类名来创建实例
        OuterClass.StaticInnerClass inner = new OuterClass.StaticInnerClass();
        inner.accessOuterMembers(); // 输出：Outer static variable: 20
    }
}

三、匿名内部类

匿名内部类是没有名称的内部类，通常用于实现接口或继承某个类，同时只需要使用一次的情况下。匿名内部类可以在创建实例的同时进行类的定义，非常适合于快速的、一次性的任务。

代码示例：

// 定义一个接口，包含一个无参无返回值的方法 doSomething  
interface MyInterface {    
    void doSomething();    
}    
  
// 外部类 OuterClass，包含 main 方法作为程序的入口点  
public class OuterClass {    
      
    public static void main(String[] args) {    
        // 使用匿名内部类来实现 MyInterface 接口  
        // 并重写 doSomething 方法  
        MyInterface myObj = new MyInterface() {    
            @Override    
            public void doSomething() {    
                // 在控制台输出一条消息，表明该方法被调用  
                System.out.println("Doing something in Anonymous Inner Class");    
            }    
        };    
          
        // 调用匿名内部类中重写的 doSomething 方法  
        myObj.doSomething(); // 控制台输出：Doing something in Anonymous Inner Class    
          
        // 假设我们有一个方法，该方法接受 MyInterface 类型的参数  
        // 我们可以将上面创建的匿名内部类对象作为参数传递  
        useMyInterface(myObj);  
    }  
      
    // 一个示例方法，接受 MyInterface 类型的参数，并调用其 doSomething 方法  
    public static void useMyInterface(MyInterface obj) {  
        obj.doSomething(); // 再次调用 doSomething 方法  
    }  
}

在示例中，创建了一个实现了MyInterface接口的匿名内部类，并立即创建了其实例。匿名内部类不仅可以实现接口，还可以继承其他类，但需要注意的是，Java不支持多重继承，因此匿名内部类只能继承一个类或实现一个接口。

内部类访问外部类成员的限制

成员内部类和匿名内部类可以自由地访问外部类的所有成员，包括私有的。但是静态内部类由于不依赖于外部类的实例，因此只能访问外部类的静态成员。

总结

特性/方面	成员内部类（内部类1）	静态内部类（内部类2）	匿名内部类（内部类3）
定义位置	在外部类内部，非静态	在外部类内部，声明为static	在方法或代码块内部，没有显式名称
与外部类的关系	依赖于外部类实例	不依赖于外部类实例	通常依赖于外部类实例（如果在方法内部定义）
访问外部类成员	可以访问所有成员（包括私有）	只能访问静态成员	可以访问所有成员（如果在方法内部定义）
创建方式	通过外部类实例创建	直接创建，无需外部类实例	在定义时同时创建实例
功能	提供与外部类紧密相关的功能	提供与外部类相关但不依赖于外部类实例的功能	快速实现接口或扩展类，常用于回调和事件处理
性能	稍微有些性能开销，因为持有外部类引用	较好的性能，不持有外部类实例引用	可能有额外的性能开销，因为通常是一次性使用
适用场景	当内部类需要访问外部类实例成员时	当内部类不需要访问外部类实例成员时	当需要快速实现接口且只使用一次时
优缺点	优点：直接访问外部类所有成员；缺点：依赖外部类实例，可能导致内存泄漏	优点：不依赖外部类实例，性能较好；缺点：只能访问静态成员	优点：简洁，快速实现接口；缺点：一次性使用，可能增加代码复杂性

Java的内部类提供了一种强大的封装机制，允许我们将逻辑上紧密相关的类组织在同一个外部类中。不同类型的内部类（成员内部类、静态内部类、匿名内部类）有着不同的特性和使用场景。通过合理地使用内部类，可以编写出更加模块化和可维护的代码。