为什么内部类里面不能定义静态的?是内存加载的问题么?能解释下内部类与静态内存是怎么加载的么?

1. class Outer  
   
2. {  
   
3.         private static int num=3;  
   
4.         static class Inner    //内部类  
   
5.         {  
   
6.                 void show()  
   
7.                 {  
   
8.                         System.out.println("show run..."+num);  
   
9.                 }  
   
10.                 static void function()//如果内部类中定义了静态成员，该内部类也必须是静态的；  
    
11.                 {  
    
12.                         System.out.println("function run..."+num);  
    
13.                 }  
    
14.         }  
    
15.         public void method()  
    
16.         {  
    
17.                 Inner in=new Inner();  
    
18.                 in.show();  
    
19.         }  
    
20. }  
    
21. 
    
22. 
    
23. class  InnerClassDemo  
    
24. {  
    
25.         public static void main(String[] args)   
    
26.         {  
    
27.                 Outer out=new Outer();  
    
28.                 out.method();  
    
29.                 /*
    
30.                 //直接访问外部类中的内部类的成员（内部类非静态）
    
31.                  
    
32.                 Outer.Inner in=new Outer().new Inner();
    
33.                 in.show();
    
34.                 //也可以写作
    
35.                 Outer out-new Outer();
    
36.                 Outer.Inner in=out.new Inner();
    
37.                 in.show();
    
38.                 */  
    
39. 
    
40.                 //如果内部类是静态的，那就相当于外部类  
    
41.                 Outer.Inner in=new Outer.Inner();  
    
42.                 in.show();  
    
43. 
    
44.                 //如果内部类是静态的，成员是静态的  
    
45.                 Outer.Inner.function();  
    
46. 
    
47.         }  
    
48. }  

复制代码

内部类可以是静态的，而且内部类里面可以有静态成员呀。
如果内部类有静态成员的话，那么内部类必须是静态。

简单来说：类的概念就是提供的一个模板，我们需要的时候才实例化它，开辟内存。

静态的对象，在内存中实默认实例化的，在加载的时候就会存放到内存中。
也就是可以直接调用而不需要手动实例化。
理解这个就不难理解楼主说的问题了。
首先内部的静态类他是不能直接被实例化的。你必须实例化外部类才能实例化它。而外部类不是默认加载的，他只有在手动实例化之后才有内存分配。

这时问题出现了。既然静态对象是默认加载，那么静态内部类应该先于外部类被加载到内存中。

那么这是又和我们之前的一个结论相反（首先内部的静态类他是不能直接被实例化的。你必须实例化外部类才能实例化它。）所以这种写法是错误的。

这会产生歧义。比如

class Outer {
  int outerX;
  Inner inner1 = new Inner();
  Inner inner2 = new Inner();
  class Inner {
    int innerX;
  }
}

Outer outer1 = new Outer();
Outer outer2 = new Outer();

假如innerX是static的，那么这个static的含义是
1：仅是同一outer实例下的不同inner实例共享：
outer1.inner1.innerX=outer1.inner2.innerX，And
outer2.inner1.innerX=outer2.inner2.innerX，But
outer1.inner1.innerX!=outer2.inner1.innerX，Hence
outer1.inner2.innerX!=outer2.inner2.innerX

2: 所有outer实例的inner实例都共享：
outer1.inner1.innerX=outer1.inner2.innerX，And
outer2.inner1.innerX=outer2.inner2.innerX，And
outer1.inner1.innerX=outer2.inner1.innerX，Hence
outer1.inner2.innerX=outer2.inner2.innerX