Java语言基础：内部类

于 2011-03-29 09:10:52 发布
阅读量59 收藏
点赞数
文章标签： 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. }  
// 外部类 class OutterClass { // 内部类 public class InnerClass { private int i = 0; public int getInt(){ return i; } } public void proc(){ InnerClass inClass = new InnerClass(); System.out.println(inClass.getInt()); } } public class Main { public static void main(String[] args) { OutterClass outClass = new OutterClass(); outClass.proc(); } }  
  • 外部类可以访问内部类的私有成员，内部类也可以访问外部类的私有成员：

  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. }  
// 外部类 class OutterClass { private int mOut = 10; // 内部类 public class InnerClass { private int mIn = 0; public void printOutPrivate(){ // 直接打印外部类的成员 System.out.println(mOut); } } public void printInPrivate(){ InnerClass inClass = new InnerClass(); // 直接打印内部类的私有成员 System.out.println(inClass.mIn); } public void printOutPrivate(){ InnerClass inClass = new InnerClass(); inClass.printOutPrivate(); } } public class Main { public static void main(String[] args) { OutterClass outClass = new OutterClass(); outClass.printInPrivate(); outClass.printOutPrivate(); } }  
  • 如果外部类的成员变量与内部类的成员变量名字相同，当内部类要访问外部类的该成员时，可以使用“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. }  
// 外部类 class OutterClass { private int mMem = 10; // 内部类 public class InnerClass { private int mMem = 0; public void printOutPrivate(){ // 直接打印外部类的成员 System.out.println(OutterClass.this.mMem); } } }  
  • 要创建普通内部类，必须先创建相应的外部类：

  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. }  
// 外部类 class OutterClass { private int mMem = 10; // 内部类 public class InnerClass { private int mMem = 0; public void printOutPrivate(){ // 直接打印外部类的成员 System.out.println(OutterClass.this.mMem); } } } public class Main { public static void main(String[] args) { OutterClass outClass = new OutterClass(); OutterClass.InnerClass inClass = outClass.new InnerClass(); inClass.printOutPrivate(); } }  
也可以用下面的方式：


  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. }  
// 外部类 class OutterClass { private int mMem = 10; // 内部类 public class InnerClass { private int mMem = 0; public void printOutPrivate(){ // 直接打印外部类的成员 System.out.println(OutterClass.this.mMem); } } public InnerClass newInnerClass() { return new InnerClass(); } } public class Main { public static void main(String[] args) { OutterClass outClass = new OutterClass(); OutterClass.InnerClass inClass = outClass.newInnerClass(); inClass.printOutPrivate(); } }  
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. }  
// 外部类 class OutterClass { private int mMem = 0; // 静态内部类 static public class InnerClass { private int mMem = 0; public void printOutPrivate(){ // 这是错误的 // System.out.println(OutterClass.this.mMem); } } public void printInPrivate() { InnerClass inClass = new InnerClass(); // 可以直接访问静态内部类的成员 System.out.println(inClass.mMem); } } public class Main { public static void main(String[] args) { // 直接创建静态内部类 OutterClass.InnerClass inClass = new OutterClass.InnerClass(); inClass.printOutPrivate(); } }  
从上面描述可以看出，静态内部类与一般类没有太大区别，只不过它是放在一个类的里面，这个类相当于它的名字空间，可以防止命名冲突。
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. }  
// 外部类 class OutterClass { public void testLocalInner() { if (true) { class LocalInner { public void proc() { System.out.println("hello"); } } // 可以创建使用 LocalInner localInner = new LocalInner(); localInner.proc(); } // 错误：超出类定义的作用域 LocalInner localInner = new LocalInner(); localInner.proc(); } }  
局部内部类的一般用途是实现某个接口，并作为这个接口传出方法被使用：
 

  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. }  
// 接口 interface Talker { public void Talk(); } // 外部类 class OutterClass { public Talker getTalker() { // 现实该接口的局部内部类 class SomeTalker implements Talker { public void Talk() { System.out.println("hello"); } } // 创建类实例并作为Talker返回 SomeTalker talker = new SomeTalker(); return talker; } } public class Main { public static void main(String[] args) { OutterClass outClass = new OutterClass(); Talker talker = outClass.getTalker(); talker.Talk(); } }  
4.  匿名内部类
匿名内部类的语法如下：
 

  1. new  InterfaceName(){......}; 或  new  SuperclassName(){......};   
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. }  
// 接口 interface Talker { public void Talk(); } // 外部类 class OutterClass { public void Talk(Talker talker) { talker.Talk(); } } public class Main { public static void main(String[] args) { OutterClass outClass = new OutterClass(); // 直接生成一个匿名内部类 outClass.Talk(new Talker(){ public void Talk() { System.out.println("hello"); } }); } }
iteye_20309
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值