public class InnerClass {
    public static void main(String[] args) {
               int m=OuterA.InnerA.i;
             OuterA.InnerA innera=new OuterA.InnerA();//静态内部类对象不依赖于外部类对象的存在
             innera.m1();
               
            OuterA out=new OuterA();
     //                OuterA.InnerB inn=new OuterA.InnerB();//静态内部类和成员内部类的区别
            OuterA.InnerB innb=out.new InnerB("san");//成员内部类对象依赖于外部类对象的存在
         //上面那条语句编译器编译时 相当于将 out对象当做参数通过构造方法传进InnerB类中
    //         OuterA.InnerB innb2=new InnerB("san",out);
             innb.m2();
        }

}

class OuterA
{
  private String name1="hello";
  private static String name2="haha";
  //静态内部类，相当于一个静态成员
  public static class InnerA{
          public static int i=9;
          public void m1()
          {
//                 System.out.println(name1);//得出静态内部类只能访问外部类的静态成员
                  System.out.println(name2);
          }  
  }
  public class InnerB
  {
      InnerB(String name )
          {
                    }
          public void m2()
          {
          System.out.println(OuterA.this.name1);//在成员内部类中访问外部类的当前对象
                  System.out.println(name2);
                  System.out.println(name2);
   }
  }
}

我补充一点(这个内容我在其他帖子也发过)

1. 
   
2. public class StaticTest {
   
3.        
   
4.        
   
5.         private static String str="外部类的静态str";
   
6.        
   
7.         private String str2="外部类的成员str";
   
8. 
   
9.         /**
   
10.          * @param args
    
11.          */
    
12.         public static void main(final String[] args) {
    
13.                 // TODO Auto-generated method stub
    
14.                 class local{
    
15.                         //private static String str="局部内部类的static str";//编译器提示"The field str cannot be declared static;
    
16.                                                                                                                         //static fields can only be declared in static or top level types"
    
17.                         private String str="局部内部类的非静态str";
    
18.                         /*public static void sop_static()//编译器提示"The method sop_static cannot be declared static;
    
19.                                                        //static methods can only be declared in a static or top level type"
    
20.                         {
    
21.                                 System.out.println(StaticTest.str);
    
22.                                 System.out.println(str);
    
23.                         }*/
    
24.                        
    
25.                         public void sop()
    
26.                         {
    
27.                                 System.out.println(StaticTest.str);
    
28.                                 System.out.println(str);
    
29.                         }
    
30.                 }
    
31.                
    
32.                 //查看局部内部类的情况
    
33.                 System.out.println("下面检验局部内部类");
    
34.                 new local().sop();
    
35.                
    
36.                 //查看成员内部类的情况
    
37.                 System.out.println("下面检验成员内部类");
    
38.                 new StaticTest().new Inner1().sop();
    
39.                
    
40.                 //查看静态内部类
    
41.                 System.out.println("下面检验静态内部类");
    
42.                 Inner2.sop_static();
    
43.                
    
44.         }
    
45.        
    
46.         /**
    
47.          *
    
48.          * @author Administrator
    
49.          *
    
50.          */
    
51.         class Inner1{
    
52.                 private static final String str="成员内部类的静态static变量";//如果不加final则编译器报错，报错的信息同上
    
53.                 public void sop()
    
54.                 {
    
55.                         System.out.println(StaticTest.str);
    
56.                         System.out.println(str);
    
57.                 }
    
58.                
    
59.                 /*public static void sop_static()//编译器报错，报错信息同上
    
60.                 {
    
61.                         System.out.println(StaticTest.str);
    
62.                         System.out.println(str);
    
63.                 }*/
    
64.                
    
65.         }
    
66.        
    
67.        
    
68.         /**
    
69.          *
    
70.          * @author Administrator
    
71.          *
    
72.          */
    
73.         static class Inner2{
    
74.                 private static String str="静态内部类的static变量";//编译器不报错
    
75.                 private String str_filed="静态内部类的成员变量";//编译器不报错
    
76.                
    
77.                 public void sop()
    
78.                 {
    
79.                         System.out.println(StaticTest.str);
    
80.                         //System.out.println(str2);这是从你的帖子学习的
    
81.                         System.out.println(str);
    
82.                 }
    
83.                
    
84.                 public static void sop_static()//编译器不报错
    
85.                 {
    
86.                         System.out.println(StaticTest.str);
    
87.                         System.out.println(str);
    
88.                 }
    
89.         }
    
90. 
    
91. }
    

复制代码

从上面这个例子我们可以看出来成员内部类内不能定义静态成员变量，但是可以定义静态成员常量，局部内部类也是这样。在静态内部类中没有限制，都可以定义。