浅谈非静态内部类不能有静态成员

1 非静态内部类为什么不能有静态成员，我自己总结了下，

如下代码

public class OuterClass{
     class InnerClass{
         private static int i;
     }
}

 对于java类加载顺序我们知道，首先加载类，执行static变量初始化，接下来执行对象的创建，如果我们要执行代码中的变量i初始化，

那么必须先执行加载OuterClass，再加载Innerclass，最后初始化静态变量i，问题就出在加载Innerclass上面，我们可以把InnerClass看成OuterClass的非静态成员，它的初始化必须在外部类对象创建后以后进行，要加载InnerClass必须在实例化OuterClass之后完成 ，java虚拟机要求所有的静态变量必须在对象创建之前完成，这样便产生了矛盾。

Verion 0.11:

对于红色标记的部分，当时理解上有误，我们知道InnerClass可以有静态常量（static final），那么InnerClass类加载一定在OuterClass对象创建之前完成，但这还不足以说明为什么非静态内部类里面不能有静态的变量（基本类型 或对象因用），这里面涉及到Java语言的定义以及JVM的类加载的原理方面的知识，我将进一步研究这个问题，技术是严谨的，也希望各位读者提出宝贵的意见。

 

下面是我验证的代码解释InnerClass加载是在OuterClass对象创建之前完成的：

public class OuterClass {
	
	static int k = printI();
	
	static int printI(){
		System.out.println("Inner Class is loading before creating OuterClass instance");
		return InnerClass.i ;
	}
	
	OuterClass(){
		System.out.println("OuterClass constructor");
	}
	
	class InnerClass{
		private static final int i = 1;
		
	}
	public static void main(String[] args) {
		OuterClass o;
	}
}
//* out:
// Inner Class is loading before creating OuterClass instance

 

2 静态内部类可以有静态成员：

我们可以把静态内部类作为外部类OuterClass的一个静态成员，在执行类加载过程中，静态内部类在加载OuterClass后会进行初始化，同样的原理，静态内部类的静态成员也将被初始化，进行内存的分配，注意到，这时无论是内部类还是外部类，对象都没有实例化，这也说明了非静态内部类为什么不能有静态成员的原因。

public class OuterClass{
     static class InnerClass{
         private static int i;
     }
}

评论

17 楼 logic 2010-06-14  

对"非静态内部类不能有静态成员"发表一下自己的见解，还请大家多指教。

其实，根本原因在于sun怎么设计内部类怎么依附于外部类这个关系。
(大家可以对内部类抽象成为外部类的一个局部域，不要束缚在单独类的基本概念上，在这里是一个特殊类了。)

实际把非静态内部类比做外部类的非静态方法容易理解一点，原因和在非静态方法中定义静态成员一个道理。
 

16 楼 Arron.li 2010-05-19  

快乐柠檬 写道

    
 class OuterClass{   
	 {
		 System.out.println(InnerClass.i);//在OuterClass类内部可能会访问InnerClass的静态成员，不保证InnerClass已初始化
		 System.out.println(InnerClass.ii);
	 }
	     class InnerClass{   
	         private static int i;  //error
	         static final int ii=1;//OK，编译器常量，不需要对InnerClass初始化就可以读取
	     }   
}

这是因为static final是编译期常量，类加载之前就已经分配内存。

15 楼 raito_yagami 2010-05-18  

回去翻翻 thinking in java 你就明白了

14 楼 快乐柠檬 2010-05-18  

    
 class OuterClass{   
	 {
		 System.out.println(InnerClass.i);//在OuterClass类内部可能会访问InnerClass的静态成员，不保证InnerClass已初始化
		 System.out.println(InnerClass.ii);
	 }
	     class InnerClass{   
	         private static int i;  //error
	         static final int ii=1;//OK，编译器常量，不需要对InnerClass初始化就可以读取
	     }   
}

13 楼 Arron.li 2010-05-18  

再次纠正问题：

引用

对于红色标记的部分，当时理解上有误，我们知道 InnerClass可以有静态常量（static final），那么InnerClass类加载一定在OuterClass对象创建之前完成

通过进一步研究类加载的原理，我们知道Class对象仅在需要时才会被加载，static初始化是在类加载进行的，所以当我们没有使用内部类时不会加载，也就是说外部类的加载与创建于内部类的加载没有必然的联系，我们现在解释为什么非静态内部类不能有静态成员（排除静态常量）是一种java的约定，可能是sun程序员用以有别于静态内部类的考虑。
下面是解释Class对象仅在需要时才会被加载的例子：

class Candy {
  static { print("Loading Candy"); }
}

class Gum {
  static { print("Loading Gum"); }
}

class Cookie {
  static { print("Loading Cookie"); }
}

public class SweetShop {
  public static void main(String[] args) {	
    print("inside main");
    new Candy();
    print("After creating Candy");
    try {
      Class.forName("Gum");
    } catch(ClassNotFoundException e) {
      print("Couldn't find Gum");
    }
    print("After Class.forName(\"Gum\")");
    new Cookie();
    print("After creating Cookie");
  }
} /* Output:
inside main
Loading Candy
After creating Candy
Loading Gum
After Class.forName("Gum")
Loading Cookie
After creating Cookie
*///:~

12 楼 czpsailer 2010-05-07  

<pre name="code" class="java"> public class OuterClass {
public class InnerClass {
//基本数据类型和String,可以
static final int i = 0;
static final byte b = 0;
static final String str = "";
static final long l = 0;
static final double d = 0;
static final char c = 0;
static final short s = 0;
static final boolean bool = true;
static final float f = 0;
           
//其他类型对象,不可以
static final Object object = null; //这里编译错误
}
}</pre>

11 楼 Aoogoo 2010-05-07  

等lz研究清楚了，再来给我们讲解

10 楼 coffeesweet 2010-05-07  

final定义了常量，可以直接初始化

9 楼 Arron.li 2010-05-07  

查了下sun公司java language specification，提到内部类的规范：
Inner classes may not declare static initializers (§8.7)  or member interfaces. Inner classes may not declare static members, unless they are compile-time constant fields (§15.28).

对于非静态内部，可以有编译常量，不过至于为什么，还有待于进一步研究。
参考网址：http://java.sun.com/docs/books/jls/third_edition/html/classes.html#8.1.3

8 楼 realcbb 2010-05-07  

关注这个问题.非静态内部类的final静态成员是何时初始化的?
singleton有一种写法就是这样的,这种写法到底是否比饿汉式好一直没搞清楚.

7 楼 chenxr 2010-05-07  

加final变量为常量了，这要区别 静态常量 与 静态变量 吧

6 楼 玲cc 2010-05-07  

为什么ls的这种写法可以呢？
求教了

5 楼 Arron.li 2010-05-06  

Agrael 写道

Arron.li 写道

Agrael 写道

    public class OuterClass{  
         class InnerClass{  
             private static final int i = 1;  
         }  
    }  

这样写。

首先static 成员不直接赋值同样也会完成自动初始化，楼上的写法没有本质的区别。

呵呵，这个区别大了，你去试下吧。

才看清楚，原来多了个final，回去好好研究下，谢谢你

4 楼 Agrael 2010-05-06  

Arron.li 写道

Agrael 写道

    public class OuterClass{  
         class InnerClass{  
             private static final int i = 1;  
         }  
    }  

这样写。

首先static 成员不直接赋值同样也会完成自动初始化，楼上的写法没有本质的区别。

呵呵，这个区别大了，你去试下吧。

3 楼 Arron.li 2010-05-06  

Agrael 写道

    public class OuterClass{  
         class InnerClass{  
             private static final int i = 1;  
         }  
    }  

这样写。

首先static 成员不直接赋值同样也会完成自动初始化，楼上的写法没有本质的区别。

2 楼 Agrael 2010-05-06  

    public class OuterClass{  
         class InnerClass{  
             private static final int i = 1;  
         }  
    }  

这样写。

1 楼 Arron.li 2010-05-06  

对于非静态内部类不能有静态成员，核心问题是在内部类的加载原理，个人认为执行内部类加载，是在外部类对象创建之后。