内部类就是在一个类的内部定义的类，内部类中不能定义静态成员。内部类可以直接访问外部类的成员变量，内部类可以定义在外部类的方法外面，也可以定义在外部类的方法体中。如下所示：

 

 
  
  1. public class Outer {  
  2.     int out_x = 0;  
  3.     private static int out_y = 1;  
  4.       
  5.     public void foo1() {  
  6.         final int b = 0;  
  7.         Inner1 inner1 = new Inner1();  
  8.           
  9.         /*  
  10.          * 内部类可以直接访问外部类的成员变量（无论是不是静态成员）  
  11.          * 方法内部定义的内部类前面不能有访问类型修饰符,但这种内部类前面可以使用final或abstract修饰符。  
  12.          * 在局部类中要访问外部类的局部变量时，该局部变量要声明为final  
  13.          */ 
  14.         class Inner2 {  
  15.             public void foo2() {  
  16.                 out_x = 3;  
  17.                 out_y = 5;  
  18.                 out_x = b; //b要声明为final  
  19.             }  
  20.         }  
  21.                    //方法内部使用内部类（局部类）时，要先定义该类，然后才能实例化  
  22.         Inner2 inner2 = new Inner2();       }  
  23.           
  24.     /*  
  25.      * 普通内部类中不能定义静态成员  
  26.      */ 
  27.     public class Inner1 {  
  28. //      public static int c = 1;  
  29.         public void foo3() {  
  30.             out_x = 3;  
  31.             out_y = 5;  
  32.         }  
  33.     }  
  34.       
  35.     /*  
  36.      * 注意：静态内部类中只能访问外部类的静态成员  
  37.      *      只能在静态内部类中定义静态成员  
  38.      */ 
  39.     public static class Inner3 {  
  40.         public static int a = 1;  
  41.         public void foo4() {  
  42. //          out_x = 3;  
  43.             out_y = 5;  
  44.         }  
  45.         public static void foo5() {  
  46.             out_y = 2;  
  47.         }  
  48.     }  
  49.  
  50. } 
 
  
    在方法体外面定义的内部类的访问类型可以是public ，protected，默认的，private等4种类型，就象类中定义的成员变量有4种访问类型一样，它们决定这个内部类的定义对其他类是否可见。对于这种情况，可以在其他类创建内部类的实例对象。不过在创建内部类的实例对象时，一定要先创建该内部类的包含类的实例对象，然后用这个实例对象去创建内部类的实例对象，代码如下：
 
  
    Outer outer = new Outer();
 
  
    Outer.Inner1 inner1 = outer.new Inner1();
 
  
    在方法体内部定义的内部类前面不能有访问类型修饰符，就像方法中定义的局部变量一样，但这种内部类的前面可以使用final或abstract修饰。这种内部对其他类是不可见的，其他类无法引用这种内部类，但是这种内部创建的实例对象可以传递给其他类访问。这种内部类必须是先定义，后使用，即内部类的定义代码必须出现在使用该类之前。这种内部类可以访问方法体中的局部变量，但是，该局部变量必须加final修饰符。
 
  
    在方法体内还可以创建一种匿名内部类，即定义某一接口或类的子类的同时，还创建了该子类的实例对象，无需为该子类定义类名：
 
  
 
 
  
 
  
  1. class Outer {  
  2.     public void start() {  
  3.         new Thread(new Runnable() {  
  4.                 public void run(){}  
  5.             }  
  6.         ).start();  
  7.     }  
  8. }