内部类:

   1、内部类成员可以直接访问外部类的私有数据,因为内部类被当成其外部类成      员,但外部类不能访问内部类的实现细节,例如内部类的属性。
   2、匿名内部类适合于创建那些仅需要一次使用的类。

   3、当调用非静态内部类的实例方法时,必须有一个非静态内部类实例,而非静态内部类实例必须寄存在外部类实例里。

 非静态内部类演示:

 
  1. package bin;  
  2. public class Cow  
  3. {  
  4.     private double weight;  
  5.     public Cow(){}  
  6.     public Cow(double weight)  
  7.     {  
  8.             this.weight = weight;  
  9.     }     
  10.     //定义一个非静态内部类  
  11.     private class CowLeg  
  12.     {  
  13.         private double length;  
  14.         private String color;  
  15.           
  16.         public CowLeg(){}  
  17.         public CowLeg(double length,String color)  
  18.         {  
  19.                 this.length = length;  
  20.                 this.color = color;  
  21.         }     
  22.         public void setLength(double length)  
  23.         {  
  24.             this.length = length;     
  25.         }  
  26.         public double getLength()  
  27.         {  
  28.             return length;    
  29.         }  
  30.         public void setColor(String color)  
  31.         {  
  32.             this.color = color;   
  33.         }  
  34.         public String getColor()  
  35.         {  
  36.             return color;     
  37.         }  
  38.         public void info()  
  39.         {  
  40.             System.out.println("当前牛腿颜色是:"+ color + ",高: "+ length);   
  41.             //直接访问外部类的private属性:weight  
  42.             System.out.println("本牛腿所在奶牛重:"+ weight);      
  43.         }  
  44.     }  
  45.     public void test()  
  46.     {  
  47.         CowLeg cl = new CowLeg(1.12,"黑白相间");  
  48.         cl.info();  
  49.     }  
  50.     public static void main(String[] args)  
  51.     {  
  52.         Cow cow = new Cow(378.9);  
  53.         cow.test();   
  54.     }  
  55. }  

 

 4、如果外部类成员变量、内部类成员变量与内部类里的方法的局部变量同名,则可以使用this、外部类类名.this作为限定来区分。例:

 

 
  1. package bin; 
  2. public class DiscernVariable 
  3.      private String prop = "外部类的实例变量"
  4.      public class InClass 
  5.      { 
  6.             private String prop = "内部类的实例变量"
  7.             public void info() 
  8.             { 
  9.                 String prop = "局部变量"
  10.                 //通过 外部类类名.this.varName 访问外部类实例 Field 
  11.                 System.out.println("外部类实例的Field值:"+ DiscernVariable.this.prop); 
  12.                 //通过 this.varName 访问内部类的实例 Field     
  13.                 System.out.println("内部类实例的Field值:"this.prop); 
  14.                 //直接访问局部变量 
  15.                 System.out.println("局部变量的值:"+ prop); 
  16.             }    
  17.      } 
  18.      public void test() 
  19.      { 
  20.             InClass in = new InClass(); //*创建内部类对象*
  21.             in.info();   
  22.      } 
  23.      public static void main(String[] args) 
  24.      { 
  25.             new DiscernVariable().test(); 
  26.      } 
  27. /* 
  28.     结果: 外部类实例的Field值:外部类的实例变量 
  29.                 内部类实例的Field值:内部类的实例变量 
  30.                 局部变量的值:局部变量 
  31. */ 

5、非静态内部类的成员只在非静态内部类范围内是可知的,并不能被外部类直接使用。

6、*非静态内部类对象必须寄存在外部类对象里,而外部类对象则不必一定有非静态内部类对象寄存其中。*

7、不允许在在外部类的静态成员中直接使用非静态内部类。例:

 

 
  1. class StaticTest 
  2.     //定义一个非静态内部类的空类 
  3.     private class In{} 
  4.     //外部类的静态方法 
  5.     public static void main(String[] args) 
  6.     { 
  7.         new In();//代码引发异常,因为静态成员(main方法)无法访问非静态成员(In类)   
  8.     }    

8、Java不允许在非静态内部类的定义静态成员。例: