Java语言基础:内部类

1.  普通内部类
  • 普通内部类的一个最简单的例子:

  1. // 外部类   
  2. class  OutterClass {  
  3.     // 内部类   
  4.     public   class  InnerClass {  
  5.         private   int  i =  0 ;  
  6.         public   int  getInt(){  
  7.             return  i;  
  8.         }  
  9.     }  
  10.     public   void  proc(){  
  11.         InnerClass inClass = new  InnerClass();  
  12.         System.out.println(inClass.getInt());  
  13.     }  
  14. }  
  15.    
  16. public   class  Main {      
  17.     public   static   void  main(String[] args) {  
  18.         OutterClass outClass = new  OutterClass();  
  19.         outClass.proc();  
  20.     }  
  21. }  
 
  • 外部类可以访问内部类的私有成员,内部类也可以访问外部类的私有成员:

  1. // 外部类   
  2. class  OutterClass {  
  3.     private   int  mOut =  10 ;  
  4.     // 内部类   
  5.     public   class  InnerClass {  
  6.         private   int  mIn =  0 ;  
  7.         public   void  printOutPrivate(){  
  8.             // 直接打印外部类的成员   
  9.             System.out.println(mOut);  
  10.         }  
  11.     }  
  12.     public   void  printInPrivate(){  
  13.         InnerClass inClass = new  InnerClass();  
  14.         // 直接打印内部类的私有成员   
  15.         System.out.println(inClass.mIn);  
  16.     }  
  17.     public   void  printOutPrivate(){  
  18.         InnerClass inClass = new  InnerClass();  
  19.         inClass.printOutPrivate();  
  20.     }  
  21. }  
  22.    
  23. public   class  Main {      
  24.     public   static   void  main(String[] args) {  
  25.         OutterClass outClass = new  OutterClass();  
  26.         outClass.printInPrivate();  
  27.         outClass.printOutPrivate();  
  28.     }  
  29. }  
 
  • 如果外部类的成员变量与内部类的成员变量名字相同,当内部类要访问外部类的该成员时,可以使用“OutClass.this.mem”来区分:

  1. // 外部类   
  2. class  OutterClass {  
  3.     private   int  mMem =  10 ;  
  4.     // 内部类   
  5.     public   class  InnerClass {  
  6.         private   int  mMem =  0 ;  
  7.         public   void  printOutPrivate(){  
  8.             // 直接打印外部类的成员   
  9.             System.out.println(OutterClass.this .mMem);  
  10.         }  
  11.     }  
  12. }  
 
  • 要创建普通内部类,必须先创建相应的外部类:

  1. // 外部类   
  2. class  OutterClass {  
  3.     private   int  mMem =  10 ;  
  4.     // 内部类   
  5.     public   class  InnerClass {  
  6.         private   int  mMem =  0 ;  
  7.         public   void  printOutPrivate(){  
  8.             // 直接打印外部类的成员   
  9.             System.out.println(OutterClass.this .mMem);  
  10.         }  
  11.     }  
  12. }  
  13.    
  14. public   class  Main {      
  15.     public   static   void  main(String[] args) {  
  16.         OutterClass outClass = new  OutterClass();  
  17.        OutterClass.InnerClass inClass = outClass.new  InnerClass();  
  18.         inClass.printOutPrivate();  
  19.     }  
  20. }  
 
也可以用下面的方式:


  1. // 外部类   
  2. class  OutterClass {  
  3.     private   int  mMem =  10 ;  
  4.     // 内部类   
  5.     public   class  InnerClass {  
  6.         private   int  mMem =  0 ;  
  7.         public   void  printOutPrivate(){  
  8.             // 直接打印外部类的成员   
  9.             System.out.println(OutterClass.this .mMem);  
  10.         }  
  11.     }  
  12.     public  InnerClass newInnerClass() {  
  13.         return   new  InnerClass();  
  14.     }  
  15. }  
  16.    
  17. public   class  Main {      
  18.     public   static   void  main(String[] args) {  
  19.         OutterClass outClass = new  OutterClass();  
  20.        OutterClass.InnerClass inClass = outClass.newInnerClass();  
  21.         inClass.printOutPrivate();  
  22.     }  
  23. }  
 
2.  静态内部类
普通内部类前面加上static修饰符,就成为静态内部类,静态内部类类似于C++的嵌套类,与普通内部类相比有如下区别:
  • 静态内部类没有指向外部类的引用,外部类对于它来说更像一个名字空间。
  • 普通内部类不能有静态成员,静态方法,或另一个静态内部类;而静态内部类可以有这一切。
  • 静态内部类可以直接创建,不必先创建外部类:

  1. // 外部类   
  2. class  OutterClass {  
  3.     private   int  mMem =  0 ;  
  4.     // 静态内部类   
  5.     static   public   class  InnerClass {  
  6.         private   int  mMem =  0 ;  
  7.         public   void  printOutPrivate(){  
  8.             // 这是错误的   
  9.             // System.out.println(OutterClass.this.mMem);   
  10.         }  
  11.     }  
  12.     public   void  printInPrivate() {  
  13.         InnerClass inClass = new  InnerClass();  
  14.         // 可以直接访问静态内部类的成员   
  15.         System.out.println(inClass.mMem);  
  16.     }  
  17. }  
  18. public   class  Main {      
  19.     public   static   void  main(String[] args) {  
  20.         // 直接创建静态内部类   
  21.         OutterClass.InnerClass inClass = new  OutterClass.InnerClass();  
  22.         inClass.printOutPrivate();  
  23.     }  
  24. }  
 
从上面描述可以看出,静态内部类与一般类没有太大区别,只不过它是放在一个类的里面,这个类相当于它的名字空间,可以防止命名冲突。
3.  局部内部类
Java可以把一个类定义在一个方法里面,甚至是一个{}块里面,它的作用域就在这个块里面:
 

  1. // 外部类   
  2. class  OutterClass {  
  3.     public   void  testLocalInner() {  
  4.         if  ( true )  
  5.         {  
  6.             class  LocalInner {  
  7.                 public   void  proc() {  
  8.                     System.out.println("hello" );  
  9.                 }  
  10.             }  
  11.             // 可以创建使用   
  12.             LocalInner localInner = new  LocalInner();  
  13.             localInner.proc();  
  14.         }  
  15.         // 错误:超出类定义的作用域   
  16.         LocalInner localInner = new  LocalInner();  
  17.         localInner.proc();  
  18.     }  
  19. }  
 
局部内部类的一般用途是实现某个接口,并作为这个接口传出方法被使用:
 

  1. // 接口   
  2. interface  Talker {  
  3.     public   void  Talk();  
  4. }  
  5.    
  6. // 外部类   
  7. class  OutterClass {  
  8.     public  Talker getTalker() {  
  9.         // 现实该接口的局部内部类   
  10.         class  SomeTalker  implements  Talker {  
  11.             public   void  Talk() {  
  12.                 System.out.println("hello" );  
  13.             }  
  14.         }  
  15.         // 创建类实例并作为Talker返回   
  16.         SomeTalker talker = new  SomeTalker();  
  17.         return  talker;  
  18.     }  
  19. }  
  20.    
  21. public   class  Main {      
  22.     public   static   void  main(String[] args) {  
  23.         OutterClass outClass = new  OutterClass();  
  24.         Talker talker = outClass.getTalker();  
  25.         talker.Talk();  
  26.     }  
  27. }  
 
4.  匿名内部类
匿名内部类的语法如下:
 

  1. new  InterfaceName(){......}; 或  new  SuperclassName(){......};   
 
 
它被认为是InterfaceName的实现者,或是SuperclassName的继承类,匿名内部类没有构建函数,如果SuperclassName有带参数的构造函数,必须在创建匿名内部类时带上这些参数,下面是匿名内部类最常见的使用场合:
 

  1. // 接口   
  2. interface  Talker {  
  3.     public   void  Talk();  
  4. }  
  5.    
  6. // 外部类   
  7. class  OutterClass {  
  8.     public   void  Talk(Talker talker) {  
  9.         talker.Talk();  
  10.     }  
  11. }  
  12.    
  13. public   class  Main {      
  14.     public   static   void  main(String[] args) {  
  15.         OutterClass outClass = new  OutterClass();  
  16.         // 直接生成一个匿名内部类   
  17.         outClass.Talk(new  Talker(){  
  18.             public   void  Talk() {  
  19.                 System.out.println("hello" );  
  20.             }  
  21.         });  
  22.     }  
  23. }  

你可能感兴趣的:(java)