关于非静态内部类为什么不能有静态成员的实践

导引

作为java开发者，我们都知道内部类分为静态内部类和非静态内部类。非静态内部类不能有静态成员（不包括静态常量），但关于为什么不能有静态成员，网上有很多不同的声音。这里我先不说自己的结论，先看真实的运行情况。

预热

1 非静态内部类是否可以包含静态常量

这个问题可能有些伙伴还没搞清楚，首先结论是可以。这里的静态常量只包括基本类型和字符串字面值。

比如下面的代码：

public class OutClass {
    String name;

    public class InClass {
        public static final int AGE = 9;
        public static final String NAME = "sollian";
    }
}

public class TestOutIn {
    public static void main(String[] args) {
        Integer age = OutClass.InClass.AGE;
        String name = OutClass.InClass.NAME;
    }
}

然后我们看下反编译TestOutIn.class的结果：

public class TestOutIn {
    public TestOutIn() {
    }

    public static void main(String[] args) {
        Integer age = 9;
        String name = "sollian";
    }
}

可以看到静态常量的引用会直接替换成它的值。这样就不依赖类的初始化，因为使用的是值，跟类无关。
而其他的数据类型或者其他形式的常量依赖于类的初始化，比如：

public static final Object obj = new Object();
public static final int COUNT = Math.max(1, 2);
public static final int COUNT_RANDOM = Random.nextInt();

首先对于obj，不可能把使用它的地方替换成new Object()。
关于COUNT可能有的同学会说，可以把用到COUNT的地方替换成Math.max(1,2)，乍一看确实没问题，但是可以思考一下：编译期间，编译器不知道Math.max(1,2)的最终结果是什么，这是运行时做的事；对编译器而言，Math.max(1,2)和Random.nextInt()没有区别，但显然我们不能用Random.nextInt()来替换COUNT_RANDOM。
以上是从逻辑上的分析。在class文件中，可以简单理解为，可以用值替换引用的静态常量必须存在于类的常量池中，比如上面提到的AGE和NAME：

   #5 = Utf8               AGE
   #6 = Utf8               I
   #7 = Utf8               ConstantValue
   #8 = Integer            9
   #9 = Utf8               NAME
  #10 = Utf8               Ljava/lang/String;
  #11 = String             #30            // sollian

关于如何查看类的字节码，可以参考如下命令：
javap -c -l -p -v *.class

注：下文提到的静态常量均是指放到常量池中的成员

知识点预热结束。上面我们提到静态常量的使用不依赖类的初始化。关于类的生命周期，可以参考Java-类的生命周期浅析或其他文章。

类初始化测试

了解了类的生命周期后，我们知道类加载的最终产物是在堆中创建类对象，即Class。类初始化是执行类的初始化语句，包括静态量的初始化，执行静态代码块。
对于下面的代码，我们测试一下哪些调用不会触发类初始化：

public class OutClass {
    public static final int AGE = 320;
    public static final String SEX = "male";
    public static final String NAME = new String("sollian");

    static {
        System.out.println("OutClass初始化");
    }

    public static void show() {
    }
}

测试代码：

public class Test {
    public static void main(String[] args) throws Exception {
        noClassInit();
//        classInit();
    }

    /**
     * 不会触发类的初始化
     */
    private static void noClassInit() throws Exception {
        System.out.println(OutClass.AGE);
        System.out.println(OutClass.SEX);
        System.out.println(OutClass.class);

        Class<OutClass> clazz = OutClass.class;
        Method method = clazz.getDeclaredMethod("show");
        System.out.println(method);
    }

    /**
     * 会触发类的初始化
     */
    private static void classInit() throws Exception {
        System.out.println(OutClass.NAME);
//        Class<?> clazz = Class.forName("com.example.javademo.OutClass");
//        OutClass.show();
    }
}

打印结果：

20
male
class com.example.javademo.OutClass
public static void com.example.javademo.OutClass.show()

可以看到，没有触发类的初始化。

执行classInit方法的结果：

OutClass初始化
sollian

可以看到，会先对类进行初始化。

了解了这些基础，我们来探索一个问题：内部类的初始化是否依赖于外部类的初始化？

内部类初始化

代码如下：

public class OutClass {
    static {
        System.out.println("OutClass初始化");
    }

    public class InClass {
        public void show() {
            System.out.println("内部类方法调用");
        }
    }
}

一般我们在外部获取内部类的实例，可以通过如下方式：

OutClass outClass = new OutClass();//先创建外部类实例
OutClass.InClass inClass =  outClass.new InClass();//再由外部类实例创建内部类实例

看下编译后的内部类文件OutClass$InClass.class的构造方法

 public com.example.javademo.OutClass$InClass(com.example.javademo.OutClass)

可以看到，虽然我们代码使用了默认的无参构造函数，但编译器会自动为我们添加外部类作为第一个参数。
了解了内部类实际的构造函数，我们可以尝试看看是否可以通过反射的方式，在不触发外部类初始化的情况下，构建内部类的实例。

public class Test {
    public static void main(String[] args) throws Exception {
        Class<OutClass.InClass> clazz = OutClass.InClass.class;
        Constructor<OutClass.InClass> constructor = clazz.getConstructor(OutClass.class);
        OutClass.InClass inClass = constructor.newInstance((OutClass) null);
        inClass.show();
    }
}

看下打印结果：

内部类方法调用

并没有触发外部类的初始化！也就是说，可以在不初始化外部类的情况下，创建内部类的实例对象。由此也可以间接说明，内部类不能有静态成员，原因并不是内部类的初始化需要依赖于外部类。

内部类不能有静态成员的原因，我目前比较倾向于是java语法的一种约束，见java的成员内部类为什么不能有静态变量(非final)和静态方法呢?
如果小伙伴有其他的观点，敬请赐教。