1. class Test{
   
2.         public static int value = 20;
   
3.         public static int num = 30;
   
4.         public static void main(String[] args){
   
5.                 Test.InnerTest.getNum();  //可以访问成员方法。
   
6.                 Test.InnerTest.num;  //这里编译时报错。
   
7.                 //System.out.println(new Test().new InnerTest().num);
   
8.                 //System.out.println(Test.value);
   
9.         }
   
10.         public  static class InnerTest{
    
11.                 public static int num = 10;
    
12.                 public static int getNum(){
    
13.                         return num;
    
14.                 }
    
15.         }
    
16. }

复制代码

上面的段代码能直接通过类名访问静态内部类的静态方法，却不能直接访问静态成员是为什么？

可以访问，但是Test.InnerTest.num；这句没有意义
我修改了一下
class Test{
        public static int value = 20;
        public static int num = 30;
        public static void main(String[] args){
                Test.InnerTest.getNum();  //可以访问成员方法。
                System.out.println(Test.InnerTest.num);  //把这段打印出。
                //System.out.println(new Test().new InnerTest().num);
                //System.out.println(Test.value);
        }
        public  static class InnerTest{
                public static int num = 10;
                public static int getNum(){
                        return num;
                }
        }
}
输出结果为10。

1. class Test
   
2. {
   
3.     public static int value = 20;
   
4.     public static int num = 30;
   
5.     public static void main(String[] args){
   
6.             Test.InnerTest.getNum();  //
   
7.             Test.InnerTest.num;                //未分配任务；这样写是毫无意义的。哪怕一个赋值语句也行
   
8.             //int b = Test.InnerTest.num;        //这样写是可以的。
   
9.             //这样写和下面两句代码类似。
   
10.             int a = 90;
    
11.             a;//这没有任何意义。没有参与程序的任何运行。
    
12.             
    
13.             //System.out.println(new Test().new InnerTest().num);
    
14.             //System.out.println(Test.value);
    
15.     }
    
16.     public  static class InnerTest{
    
17.             public static int num = 10;
    
18.             public static int getNum(){
    
19.                     return num;
    
20.             }
    
21.     }
    
22. }

复制代码

韩松范 发表于 2013-3-5 15:29
可以访问，但是Test.InnerTest.num；这句没有意义
我修改了一下
class Test{

晕，编译时老出红叉，忘了还得打印这事。

寇弘禄 发表于 2013-3-5 15:46
晕，编译时老出红叉，忘了还得打印这事。

哈哈，当年类似的问题，折磨了我一晚上，
有时候身在其中，就是怎么也找不出问题所在。

楼上的范哥，Test.InnerTest.num；这句是有意义的啊
内部类在自己所处的外部类的静态方法内构建对象或在另一个类里构造对象时应用，如下，你看：
(1)    OuterClass out = new OuterClass();
                        OuterClass.InnerClass in = out.new InnerClass();
(2)OuterClass.InnerClass in=new OuterClass().new InnerClass();
                        其中OuterClass是外部类，InnerClass是内部类。

1. class Test{
   
2. public static int value = 20;
   
3. public static int num = 30;
   
4. public static void main(String[] args){
   
5. Test.InnerTest.getNum();  //可以访问成员方法。
   
6. int t=InnerTest.num;                                        //呵呵，你也不好好看看代码！你的Test.InnerTest.num可是有返回值的哟！咱要把这返回值给接着呀，要赋值的！
   
7. //System.out.println(new Test().new InnerTest().num);     //<font color="red" size="4">还有就是外部类访问内部类的静态成员：内部类.静态成员就可以了;</font>
   
8. //System.out.println(Test.value);       //<font color="red" size="4">外部类访问内部类的非静态成员:实例化内部类即可 ,</font>     
   
9. }                                                         //<font color="red" size="4">即OuterClass.InnerClass in=new OuterClass().new InnerClass();in .内部类非静态成员；</font>
   
10. public  static class InnerTest{
    
11. public static int num = 10;
    
12. public static int getNum(){
    
13. return num;
    
14. }
    
15. }
    
16. }

复制代码

其实，静态内部类的使用，限制还是蛮多的，下面是我以前收藏的技术文档，分享给你：

1. 一是静态成员(包括静态变量与静态成员)的定义。一般情况下，如果一个内部类不是被定义成静态内部类，那么在定义成员变量或者成员方法的时候，是不能够被定义成静态成员变量与静态成员方法的。也就是说，在非静态内部类中不可以声明静态成员。如现在在一个student类中定义了一个内部类age，如果没有将这个类利用static关键字修饰，即没有定义为静态类，那么在这个内部类中如果要利用static关键字来修饰某个成员方法或者成员变量是不允许的。在编译的时候就通不过。故程序开发人员需要注意，只有将某个内部类修饰为静态类，然后才能够在这个类中定义静态的成员变量与成员方法。这是静态内部类都有的一个特性。也正是因为这个原因，有时候少了这个静态的内部类，很多工作就无法完成。或者说要绕一个大圈才能够实现某个用户的需求。这也是静态的内部类之所以要存在的一个重要原因。
   
2. 
   
3. 　　二是在成员的引用上，有比较大的限制。一般的非静态内部类，可以随意的访问外部类中的成员变量与成员方法。即使这些成员方法被修饰为private(私有的成员变量或者方法)，其非静态内部类都可以随意的访问。则是非静态内部类的特权。因为在其他类中是无法访问被定义为私有的成员变量或则方法。但是如果一个内部类被定义为静态的，那么在银用外部类的成员方法或则成员变量的时候，就会有诸多的限制。如不能够从静态内部类的对象中访问外部类的非静态成员(包括成员变量与成员方法)。这是什么意思呢?如果在外部类中定义了两个变量，一个是非静态的变量，一个是静态的变量。那么在静态内部类中，无论在成员方法内部还是在其他地方，都只能够引用外部类中的静态的变量，而不能够访问非静态的变量。在静态内部类中，可以定义静态的方法(也只有在静态的内部类中可以定义静态的方法)，在静态方法中引用外部类的成员。但是无论在内部类的什么地方引用，有一个共同点，即都只能够引用外部类中的静态成员方法或者成员变量。对于那些非静态的成员变量与成员方法，在静态内部类中是无法访问的。这就是静态内部类的最大使用限制。在普通的非静态内部类中是没有这个限制的。也正是这个原因，决定了静态内部类只应用在一些特定的场合。其应用范围远远没有像非静态的内部类那样广泛。
   
4. 
   

复制代码