class A{
        public static class B{
                public void show(){
                        int i = 30;                       
                        System.out.println(this.i);
                }
        }
}
public class Demo {
        public  static void  main(String[] args){
                new A.B().show();
        }
}

new A.B().show(); 语句是实例化外部类还是内部类

1. class A {
   
2.     public A(){
   
3.         System.out.println("A被初始化了");
   
4.     }
   
5.    
   
6.     public static class B {
   
7.         public B(){
   
8.             System.out.println("B被初始化了");
   
9.         }
   
10. 
    
11.         public void show() {
    
12.             int i = 30;
    
13.             // 这个i是局部变量,this是无法访问的
    
14.             System.out.println(i);
    
15.         }
    
16.     }
    
17. }
    
18. 
    
19. public class TestC {
    
20. 
    
21.     /**
    
22.      * @param args
    
23.      */
    
24.     public static void main(String[] args) {
    
25.         new A.B().show();
    
26.         new A.B().show();
    
27.         new A.B().show();
    
28.     }
    
29. }
    
30. 
    
31. B被初始化了
    
32. 30
    
33. B被初始化了
    
34. 30
    
35. B被初始化了
    
36. 30

复制代码

从上面这段程序的输出可以看出class A并没有被实例化，而静态static修饰的内部B类也并不是只初始化一次。这里的A仅仅起到了路标的作用，表明初始化的是A内部B类

内部类被静态化，A.B可以当做一个整体看，可以直接new 出内部类的对象
通过A访问B，不需要生成外部类对象
/*new A.B().show();错了吧；
内部类非静态：访问内部类方式：
        A.B  in=new A().new B();
        in.show();
或者：
     A a=new A();
    A.B in=a.new B();
    in.show();
1、开头的A是为了表明生成的内部类对象是属于哪个外部中；
2、必须要有外部类对象才能生成内部类对象，因为内部类的作用就是访问外部类中的成员变量；
*/

抱歉，刚才说错了
内部类被静态化，A.B可以当做一个整体看，可以直接new 出内部类的对象
通过A访问B，不需要生成外部类对象；

yuanlingqi 发表于 2014-11-10 12:06
从上面这段程序的输出可以看出class A并没有被实例化，而静态static修饰的内部B类也并不是只初始化一次。这 ...

简单明了，强

class A并没有被实例化，而静态static修饰的内部B类也并不是只初始化一次。A是指引的，表明初始化的是A内部B类

学习到了，谢谢= =

当你想进黑马的时候,游戏就已经开始了

哎，我的黑马币一去不回啊……

过来学习下。内部类我也学得有很懵:L