Java内部类

在Java中，内部类（Inner Class）是定义在另一个类（外部类）内部的类。内部类可以访问外部类的私有成员和方法，并且可以被视为外部类的一个成员。下面是一些Java内部类的例子：

静态内部类（Static Nested Class）

静态内部类不持有外部类的实例引用，它可以访问外部类的静态成员，但不能直接访问外部类的非静态成员（除非通过外部类的实例）。

public class OuterClass {  
    private static int staticVar = 100;  
      
    // 静态内部类  
    public static class StaticNestedClass {  
        void display() {  
            System.out.println("Static Nested Class");  
            System.out.println("Accessing OuterClass static variable: " + staticVar);  
        }  
    }  
  
    public static void main(String[] args) {  
        StaticNestedClass nestedObj = new StaticNestedClass();  
        nestedObj.display();  
    }  
}

非静态内部类（Inner Class）

非静态内部类（也称为成员内部类）持有外部类的实例引用（通过this$0隐式引用），它可以访问外部类的所有成员（包括私有成员）。

public class OuterClass {  
    private int instanceVar = 200;  
      
    // 非静态内部类  
    class InnerClass {  
        void display() {  
            System.out.println("Inner Class");  
            System.out.println("Accessing OuterClass instance variable: " + instanceVar);  
            System.out.println("Accessing OuterClass instance using OuterClass.this: " + OuterClass.this.instanceVar);  
        }  
    }  
  
    public void testInnerClass() {  
        InnerClass innerObj = new InnerClass();  
        innerObj.display();  
    }  
  
    public static void main(String[] args) {  
        OuterClass outerObj = new OuterClass();  
        outerObj.testInnerClass();  
    }  
}

局部内部类（Local Inner Class）

局部内部类定义在外部类的方法中，它只能访问方法中定义的final或等同于final的局部变量（Java 8开始，只要局部变量在事实上不会被修改，就可以被局部内部类访问）。

public class OuterClass {  
    public void testLocalInnerClass() {  
        final int localVar = 300; // 必须是final或等同于final  
  
        // 局部内部类  
        class LocalInnerClass {  
            void display() {  
                System.out.println("Local Inner Class");  
                System.out.println("Accessing local variable: " + localVar);  
            }  
        }  
  
        LocalInnerClass localInnerObj = new LocalInnerClass();  
        localInnerObj.display();  
    }  
  
    public static void main(String[] args) {  
        OuterClass outerObj = new OuterClass();  
        outerObj.testLocalInnerClass();  
    }  
}

匿名内部类（Anonymous Inner Class）

匿名内部类是没有类名的内部类，通常用于实现接口或继承一个类，并立即创建一个实例。它们常用于事件监听器或适配器等场景。

import java.awt.event.ActionListener;  
import javax.swing.JButton;  
  
public class OuterClass {  
    JButton button;  
  
    public OuterClass() {  
        button = new JButton("Click me");  
  
        // 匿名内部类实现ActionListener接口  
        button.addActionListener(new ActionListener() {  
            @Override  
            public void actionPerformed(java.awt.event.ActionEvent e) {  
                System.out.println("Button clicked!");  
            }  
        });  
    }  
  
    public static void main(String[] args) {  
        // 在实际应用中，这里可能会创建GUI并显示按钮  
        OuterClass outerObj = new OuterClass();  
        // ...  
    }  
}