Java 中静态内部类和非静态内部类的区别是什么？

推荐答案

在Java中，静态内部类和非静态内部类的主要区别如下：

1. 实例化方式：

   • 静态内部类可以直接通过外部类名进行实例化，不需要依赖外部类的实例。
   • 非静态内部类必须通过外部类的实例进行实例化。

2. 访问外部类成员：

   • 静态内部类不能直接访问外部类的非静态成员（变量和方法），只能访问外部类的静态成员。
   • 非静态内部类可以直接访问外部类的所有成员（包括静态和非静态）。

3. 内存占用：

   • 静态内部类不持有外部类的引用，因此不会增加外部类的内存占用。
   • 非静态内部类持有外部类的引用，因此会增加外部类的内存占用。

4. 生命周期：

   • 静态内部类的生命周期独立于外部类，即使外部类被垃圾回收，静态内部类仍然可以存在。
   • 非静态内部类的生命周期依赖于外部类，如果外部类被垃圾回收，非静态内部类也会被回收。

本题详细解读

1. 实例化方式

静态内部类的实例化方式如下：

OuterClass.StaticInnerClass staticInner = new OuterClass.StaticInnerClass();

非静态内部类的实例化方式如下：

OuterClass outer = new OuterClass();
OuterClass.NonStaticInnerClass nonStaticInner = outer.new NonStaticInnerClass();

2. 访问外部类成员

静态内部类不能直接访问外部类的非静态成员，但可以通过外部类的实例来访问：

// www.javascriptcn.com code example
class OuterClass {
    private static int staticVar = 10;
    private int nonStaticVar = 20;

    static class StaticInnerClass {
        void accessOuter() {
            System.out.println(staticVar); // 可以直接访问静态变量
            // System.out.println(nonStaticVar); // 编译错误，不能直接访问非静态变量
            OuterClass outer = new OuterClass();
            System.out.println(outer.nonStaticVar); // 通过外部类实例访问非静态变量
        }
    }
}

非静态内部类可以直接访问外部类的所有成员：

// www.javascriptcn.com code example
class OuterClass {
    private static int staticVar = 10;
    private int nonStaticVar = 20;

    class NonStaticInnerClass {
        void accessOuter() {
            System.out.println(staticVar); // 可以直接访问静态变量
            System.out.println(nonStaticVar); // 可以直接访问非静态变量
        }
    }
}

3. 内存占用

静态内部类不持有外部类的引用，因此不会增加外部类的内存占用。而非静态内部类持有外部类的引用，因此会增加外部类的内存占用。

4. 生命周期

静态内部类的生命周期独立于外部类，即使外部类被垃圾回收，静态内部类仍然可以存在。而非静态内部类的生命周期依赖于外部类，如果外部类被垃圾回收，非静态内部类也会被回收。

// www.javascriptcn.com code example
class OuterClass {
    static class StaticInnerClass {
        void print() {
            System.out.println("Static Inner Class");
        }
    }

    class NonStaticInnerClass {
        void print() {
            System.out.println("Non-Static Inner Class");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        OuterClass.StaticInnerClass staticInner = new OuterClass.StaticInnerClass();
        staticInner.print();

        OuterClass outer = new OuterClass();
        OuterClass.NonStaticInnerClass nonStaticInner = outer.new NonStaticInnerClass();
        nonStaticInner.print();
    }
}

在这个例子中，StaticInnerClass的生命周期独立于OuterClass，而NonStaticInnerClass的生命周期依赖于OuterClass。