Java 内部类包含静态内部类（Static Nested Class）、非静态内部类（Inner Class）

在 Java 中，内部类主要分为以下几种类型：

1. 成员内部类（Member Inner Class）
2. 静态内部类（Static Nested Class）
3. 局部内部类（Local Inner Class）
4. 匿名内部类（Anonymous Inner Class）

1. 成员内部类（Member Inner Class）

这是最常见的内部类之一，作为外部类的一个成员存在。它不使用 static 修饰符，可以访问外部类的所有成员变量和方法。

特点：

• 需要通过外部类的实例来创建。
• 可以访问外部类的所有成员，包括私有成员。

代码示例：

class OuterClass {
    private int outerField = 10;

    // 成员内部类
    class InnerClass {
        void display() {
            System.out.println("Outer Field: " + outerField);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();
        inner.display();
    }
}

2. 静态内部类（Static Nested Class）

静态内部类与成员内部类类似，但它使用 static 关键字修饰，不依赖外部类的实例，不能直接访问外部类的非静态成员。

特点：

• 不需要外部类的实例即可创建。
• 只能访问外部类的静态成员。

代码示例：

class OuterClass {
    private static int staticField = 20;

    // 静态内部类
    static class StaticNestedClass {
        void display() {
            System.out.println("Static Field: " + staticField);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        OuterClass.StaticNestedClass nested = new OuterClass.StaticNestedClass();
        nested.display();
    }
}

3. 局部内部类（Local Inner Class）

局部内部类是在方法或代码块内部定义的类，类似于局部变量，作用范围仅限于定义它的方法或块中。

特点：

• 只能在定义它的作用域内使用。
• 可以访问外部类的成员和方法中的局部变量（这些局部变量必须是 final 或有效 final，即在定义后没有再修改过）。

代码示例：

class OuterClass {
    void method() {
        final int localVar = 30;

        // 局部内部类
        class LocalInnerClass {
            void display() {
                System.out.println("Local Variable: " + localVar);
            }
        }

        LocalInnerClass localInner = new LocalInnerClass();
        localInner.display();
    }
}

public class Test {
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.method();
    }
}

4. 匿名内部类（Anonymous Inner Class）

匿名内部类是一种没有名字的局部内部类，通常在需要简洁实现接口或抽象类的场合使用。它可以在同一时间创建类的实例并定义其行为。

特点：

• 没有类名，直接使用 {} 定义。
• 只能用来实例化接口或抽象类，或者继承一个具体的类。

代码示例：

interface Greeting {
    void sayHello();
}

public class Test {
    public static void main(String[] args) {
        // 匿名内部类
        Greeting greeting = new Greeting() {
            @Override
            public void sayHello() {
                System.out.println("Hello from Anonymous Inner Class!");
            }
        };
        
        greeting.sayHello();
    }
}

各类内部类的使用场景：

• 成员内部类：用于一个类逻辑上需要划分为多个类时，并且需要内部类访问外部类的实例变量和方法的场景。
• 静态内部类：用于当内部类不需要访问外部类的实例成员时，并且希望减少外部类和内部类之间耦合的场景。
• 局部内部类：适用于需要在方法或代码块中临时定义类的场景。
• 匿名内部类：适合用来简化代码，特别是在只需要实现一次接口或者继承某个类的场景中。

总结来说，Java 提供了多种内部类类型，以便根据不同的需求对代码结构进行优化和简化。