1. class Noname5
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 Outer.Inter.run();   //主函数调用
   
6.         }
   
7. }
   
8. 
   
9. class Outer                     //外部类，非静态
   
10. {
    
11.         static int x =3;         //静态外部类成员变量
    
12. 
    
13.         static class Inter       //静态内部类
    
14.         {
    
15.                 static void run()        //静态内部类成员方法
    
16.                 {
    
17.                         System.out.println(x);
    
18.                 }
    
19.         }
    
20. }

复制代码

如上代码：
为什么在主函数中，使用 Outer.Inter.run();就可以？
就算Inter是静态类，可是Outer是非静态的啊，还没有创建Outer对象，哪里来的Inter呢？

是不是 编译过程中，已经生成了Outer和Inter的class文件，然后运行的时候因为Outer中有Inter这个静态 所以自己就进了内存了？

因为正常方法中如;
class Test
{

}
class Demo
{
public static void main(String [] args)
{
   
}
}

编译之后是会有Test.class文件的，可是在主函数中不创建Test的对象，这个class文件是不会进内存的只在磁盘上保留啊。

因为内部类带个静态那么这个class文件就不需要主函数自行就会进入内存吗？进入静态区？

还请高手解答。

好吧，我2B了，其实这问题很简单。

class Test
{
static run()
{}
}

class Demo
{
public static void main(String[] atgs)
{
Test.run();           //本来就可以直接这样的。。。。。我自己犯晕了，现在明白了，就想探讨一下原理。
}
}


如上代码，我自己思维混乱了。。


不过不疑问这个问题了，

现在想知道就像上面说的，如果我没有创建Test对象，而主函数直接Test.run(); 就用了，那么是否说明，包含静态的类会自动加载进内存？

为什么用Outer.Inter.run();就可以？
类中的类可以理解为类中的普通方法和属性，因为Inter是静态的，所以静态的可以被类名的直接调用，所以Outer.Inter.
同理 run方法也是静态的，也可以类名调用，所以用Inter.run();如果要调用类中类中的方法，所以Outer.Inter.run();。

static修饰后的成员具备以下特点：
         1,随着类的加载而加载，也就是说，静态会随着类的消失而消失，它的生命周期最长。
         2,优先于对象存在
         3,被所有对象所共享
         4,可以直接被类名调用
jvm运行的时候，Demo类和Test类都会被加载进内存，静态的run()方法随着类的加载而加载。

任江峰 发表于 2013-5-9 21:41
static修饰后的成员具备以下特点：
         1,随着类的加载而加载，也就是说，静态会随着类的消失而消失， ...

恩，意思就是JVM一运行，所有能用到的类都会自动进内存是吧，而不是创建了对象才会进去
？

曹宇 发表于 2013-5-10 13:35
恩，意思就是JVM一运行，所有能用到的类都会自动进内存是吧，而不是创建了对象才会进去
？ ...

是这样的。

    class Noname5
    {
            public static void main(String[] args)
                               
            {
                    Outer.Inter.run();   //主函数调用
            }
    }

    class Outer                     //外部类，非静态
    //
        {
            static int x =3;         //静态外部类成员变量

            static class Inter       //静态内部类
            {
                    static void run()        //静态内部类成员方法
                    {
                            System.out.println(x);
                    }
            }
    }

        这个道理其实很简单。不要把它想的那么复杂。我给你解释下程序的执行过程你就全明白了。我们可以把静态内部类当成一个
        普通的静态成员。只要是静态就会随着类的加载而加载对不对。。同时也会被存储到方法区里。这样就能被类名点调用了。
        那么我用外部类的类名调用它的静态成员也没问题吧？然后就很正常了。调用内部类中的静态方法就是java的基本特性了。

问题解决请编辑改为已解决，有疑问可以继续追问