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

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

一、成员内部类

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

代码示例：

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不支持多重继承，因此匿名内部类只能继承一个类或实现一个接口。

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

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

总结

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