前言

在Java中，内部类（Inner Class）是定义在另一个类内部的类。内部类有多种类型，包括成员内部类、静态内部类、局部内部类和匿名内部类。每种类型的内部类都有不同的特点和用途。

内部类分类

成员内部类（Member Inner Class） ：

• 成员内部类是定义在另一个类的内部的类。
• 成员内部类具有与外部类实例相关联的特性，因此可以访问外部类的成员变量和方法。
• 创建成员内部类的实例需要先创建外部类的实例，然后通过外部类实例来创建内部类实例。

public class OuterClass {
    private int outerVar = 10;

    public class InnerClass {
        public void innerMethod() {
            System.out.println("内部类访问外部类变量: " + outerVar);
        }
    }
    
    public void outerMethod() {
        InnerClass inner = new InnerClass();
        inner.innerMethod();
    }
}

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

静态内部类（Static Nested Class） ：

• 静态内部类是与外部类无关的，它不依赖于外部类的实例。
• 静态内部类可以包含静态成员变量和静态方法，而不需要外部类的实例。
• 创建静态内部类的实例不需要先创建外部类的实例，可以直接通过类名访问。

public class OuterClass {
    private static int outerStaticVar = 5;

    public static class StaticInnerClass {
        public void innerMethod() {
            System.out.println("静态内部类访问外部类静态变量: " + outerStaticVar);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        OuterClass.StaticInnerClass inner = new OuterClass.StaticInnerClass();
        inner.innerMethod();
    }
}

局部内部类（Local Inner Class） ：

• 局部内部类是定义在方法或代码块内部的类，它的作用范围限定在方法或代码块内。
• 局部内部类通常用于解决某个特定方法或代码块的问题，具有局部性和封装性。

public class OuterClass {
    public void outerMethod() {
        class LocalInnerClass {
            public void innerMethod() {
                System.out.println("局部内部类的方法");
            }
        }
        LocalInnerClass inner = new LocalInnerClass();
        inner.innerMethod();
    }
}

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

匿名内部类（Anonymous Inner Class） ：

• 匿名内部类是一种没有显式名称的内部类，通常用于创建一个临时的、只使用一次的类。
• 匿名内部类通常作为参数传递给方法，例如在事件处理器或线程创建时。

public class OuterClass {
    public void greet() {
        Greeting greeting = new Greeting() {
            @Override
            public void sayHello() {
                System.out.println("Hello from anonymous inner class!");
            }
        };
        greeting.sayHello();
    }
    
    interface Greeting {
        void sayHello();
    }
}

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

内部类初始化

1. 外部类和内部类的初始化时机：外部类的初始化通常是在首次使用该类之前进行的，而内部类的初始化则取决于内部类的类型。如果内部类是静态的，它将在首次使用外部类之前初始化。如果内部类是非静态的（成员内部类），则需要首先创建外部类的实例，然后才能创建内部类的实例。

2. 静态内部类的初始化：静态内部类与外部类无关，因此它可以在外部类被加载时立即初始化，不需要外部类的实例存在。这使得静态内部类可以包含静态成员变量和静态方法。

3. 成员内部类的初始化：成员内部类是与外部类的实例相关联的，因此它的初始化要求在外部类的实例存在时才能进行。要创建成员内部类的实例，必须首先创建外部类的实例，然后通过外部类实例来创建内部类实例。这也意味着成员内部类不能包含静态成员变量或静态方法，因为它们依赖于外部类的实例。

4. 局部内部类和匿名内部类的初始化：局部内部类和匿名内部类通常在定义它们的方法中初始化。它们的生命周期与方法的执行周期相关联。局部内部类和匿名内部类可以访问外部方法的局部变量，但这些变量必须是final或effectively final的，以确保它们在内部类中不会发生变化。

内部类优点

• 封装性：内部类可以访问外部类的私有成员，这有助于封装相关功能。
• 组织性：内部类可以将相关的类放在一起，使代码更具组织性。
• 实现细节隐藏：内部类可以将实现细节隐藏在外部类之内，对外部类的使用者不可见。