导引
作为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)和静态方法呢?
如果小伙伴有其他的观点，敬请赐教。
