Java内部类和静态嵌套类详解

技术背景

在Java编程中，允许在一个类的内部定义另一个类，这种类被称为嵌套类。嵌套类分为静态嵌套类和非静态嵌套类（即内部类）。这种设计为代码的组织、封装和可读性提供了便利。

实现步骤

静态嵌套类

静态嵌套类是被声明为静态成员的嵌套类。它与外部类的实例无关，可以直接通过外部类名访问。

class OuterClass {
    static class StaticNestedClass {
        static void display() {
            System.out.println("This is a static nested class.");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        OuterClass.StaticNestedClass.display();
    }
}

内部类

内部类是被声明为非静态成员的嵌套类。它的实例必须依赖于外部类的实例。

class OuterClass {
    private String message = "Hello from outer class";

    class InnerClass {
        void display() {
            System.out.println(message);
        }
    }
}

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

局部内部类

局部内部类是在方法内部定义的类，只能在该方法内部使用。

class OuterClass {
    void outerMethod() {
        class LocalInnerClass {
            void display() {
                System.out.println("This is a local inner class.");
            }
        }
        LocalInnerClass localInner = new LocalInnerClass();
        localInner.display();
    }
}

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

匿名内部类

匿名内部类是一种没有名字的局部内部类，通常用于创建一次性的对象。

interface MyInterface {
    void display();
}

public class Main {
    public static void main(String[] args) {
        MyInterface obj = new MyInterface() {
            @Override
            public void display() {
                System.out.println("This is an anonymous inner class.");
            }
        };
        obj.display();
    }
}

核心代码

静态嵌套类

package pizza;

public class Rhino {
    public static class Goat {
        void someMethod() {
            System.out.println("This is a static nested class method.");
        }
    }
}

内部类

package pizza;

public class Rhino {
    private String barry;

    public class Goat {
        public void colin() {
            System.out.println(barry);
        }
    }
}

最佳实践

静态嵌套类

当嵌套类不需要访问外部类的实例成员时，使用静态嵌套类。例如，在实现Builder模式时，使用静态嵌套类作为Builder类：

public class BankAccount {
    private long accountNumber;
    private String owner;

    public static class Builder {
        private long accountNumber;
        private String owner;

        public Builder(long accountNumber) {
            this.accountNumber = accountNumber;
        }

        public Builder withOwner(String owner) {
            this.owner = owner;
            return this;
        }

        public BankAccount build() {
            BankAccount account = new BankAccount();
            account.accountNumber = this.accountNumber;
            account.owner = this.owner;
            return account;
        }
    }
}

内部类

当嵌套类需要访问外部类的实例成员时，使用内部类。例如，在实现事件监听器时，使用内部类：

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;

public class MyClass extends JFrame {
    private JButton button;

    public MyClass() {
        button = new JButton("Click me");
        button.addActionListener(new MyAdapter());
        add(button);
        setSize(300, 200);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setVisible(true);
    }

    class MyAdapter implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            System.out.println("Button clicked");
        }
    }

    public static void main(String[] args) {
        new MyClass();
    }
}