面试题：内部类与静态内部类的区别？

本篇记录一下最近看过的面试问题：内部类与静态内部类的区别？

下面将以较短的篇幅来讲解该面试题的知识要点，如果看完题目还没有想到答案的读者们可以往下阅读这篇文章，希望能给你带来一些收获。

内部类是什么？

在讲解内部类与静态内部类的区别之前，先来看看内部类是什么，为什么 Java 需要内部类？

内部类是指定义在另一个类中的类，它可以访问外部类的成员变量和方法，并且可以被外部类的其他成员所使用。

为什么需要使用内部类呢？主要有以下两点原因（这里引用 Java 核心技术卷1 的两句话）：

1. 内部类可以对同一个包中的其他类隐藏。

2. 内部类方法可以访问定义这个类的作用域中的数据，包括原本私有的数据。

通过代码来讲解内部类的两个特点

/**
 * 内部类测试
 * @author 单程车票
 */
public class InnerClassTest {
    public static void main(String[] args) {
        Tree tree = new Tree();
        tree.addNode(10);
        // Tree.Node = tree.new Node(10); // 编译报错，外部其他类无法使用内部类 Node
    }
}

class Tree {

    private List<Node> nodes = new ArrayList<>();

    // 通过 private 修饰 Node 内部类
    private class Node {

        private int value;

        public Node(int val) {
            value = val;
        }

        public void printLength() {
            System.out.println("插入节点值为：" + value);
            // 内部类成员可以访问外部类的私有数据
            // 更正规语法是 Tree.this.nodes.size()
            System.out.println("当前长度为：" + nodes.size());
        }
    }
    
    // 添加 Node 方法（外部类的成员可以使用内部类）
    public void addNode(int value) {
        Node node = new Node(value);
        nodes.add(node);
        node.printLength();
    }
}

运行结果：

通过上面的代码可以看到，内部类其实是可以使用 private 和 protected 这两个访问权限符来修饰的（外部类是无法通过这两个访问权限符修饰的），这也就说明了内部类是可以通过这两个访问权限符来控制对外部其他类的隐藏的。

此外，通过上面的代码还可以清晰的看到外部类 Tree 的方法（成员）可以访问到外部类的作用域内的变量，包括私有变量。这里的原理是在编译时内部类会被编译为 外部类名 + $ + 内部类名（Tree$Node.class）这样一个类文件，也就是说编译器对内部类进行了处理，与虚拟机无关。

可以看到，内部类编译后会生成一个构造器，这个构造器会比源码多带上一个参数，这个参数的类型就是外部类 Tree，并且被保存在 this$0 字段中，到这里也就能说明其实内部类在编译后会通过构造器将外部类的引用传递进来，这样内部类可以持有外部类对象引用来访问外部类的变量。

当然，除了以上两点原因之外，内部类还可以解决 Java 单继承的问题，由于篇幅问题这里就不再赘述了，有兴趣的读者们可以自行了解。

---

内部类与静态内部类的区别？

接下来，就应该谈谈面试题：内部类与静态内部类的区别了，从题目中应该也可以了解到内部类其实细分为成员内部类、局部内部类、匿名内部类和静态内部类。

所以，这道面试题其实问的就是非静态内部类和静态内部类的区别，也可以理解为成员内部类和静态内部类的区别。关于剩下两种内部类，由于内容过多且篇幅有限，这里就不做过多说明。

非静态内部类与静态内部类的区别？

非静态内部类：

• 实例化：非静态内部类的实例化必须依赖于外部类的实例化，即需要先创建外部内实例再创建非静态内部类实例（如下面代码中的 new Inner().new InnerClass()）。
• 访问外部类的变量和方法：非静态内部类可以访问外部类的所有变量和方法（包括非静态和静态）。
• 声明内部类的变量和方法：非静态内部类可以声明非静态的变量和方法，但不可以声明静态的变量和方法。

静态内部类：

• 实例化：静态内部类的实例化不依赖于外部类的实例化，即可以直接创建静态内部类实例（如下面代码中的 new Inner.StaticInnerClass()）。
• 访问外部类的变量和方法：静态内部类可以访问外部类的静态变量和静态方法，但不可以访问外部类的非静态变量和非静态方法。
• 声明内部类的变量和方法：静态内部类可以声明非静态的和静态的变量和方法。

给出代码演示：

/**
 * 测试类
 * @author 单程车票
 */
public class Inner {

    private String field = "外部非静态字段";
    private static String staticField = "外部静态字段";

    public void print() {
        System.out.println("外部非静态方法");
    }

    public static void staticPrint() {
        System.out.println("外部静态方法");
    }

    // 非静态内部类
    public class InnerClass {

        private String innerField = "内部非静态字段";
        // private static String innerStaticField = "内部静态字段"; // 编译不通过，不支持 static 声明

        public void innerPrint() {
            System.out.println("内部非静态方法");
        }

        // 编译不通过，不支持 static 声明
        // public static void innerStaticPrint() { System.out.println("内部静态方法"); }

        public void read() {
            System.out.println("读取非静态字段：" + field);
            System.out.println("读取静态字段：" + staticField);
            print(); // 调用非静态方法
            staticPrint(); // 调用静态方法
        }
    }

    // 静态内部类
    public static class StaticInnerClass {

        private String innerField = "内部非静态字段";
        private static String innerStaticField = "内部静态字段";

        public void innerPrint() {
            System.out.println("内部非静态方法");
        }

         public static void innerStaticPrint() {
              System.out.println("内部静态方法");
         }

        public void read() {
            // System.out.println("读取非静态字段：" + field); // 编译不通过，无法读取非静态字段
            System.out.println("读取静态字段：" + staticField);
            // print(); // 编译不通过，无法调用非静态方法
            staticPrint(); // 调用静态方法
        }
    }

    public static void main(String[] args) {
        // 非静态内部类实例化，依赖外部类
        Inner.InnerClass innerClass = new Inner().new InnerClass();
        // 静态内部类实例化，不依赖外部类
        Inner.StaticInnerClass staticInnerClass = new Inner.StaticInnerClass();
    }
}

使用静态内部类的时机？

只要内部类不需要访问外部类对象时，也就是不需要生成外部类对象引用时，就应该使用静态内部类。

---