Java语言基础：内部类

1.  普通内部类

    * 普通内部类的一个最简单的例子：

    view plaincopy to clipboardprint?

       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(); } }

    * 外部类可以访问内部类的私有成员，内部类也可以访问外部类的私有成员：

    view plaincopy to clipboardprint?

       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”来区分：

    view plaincopy to clipboardprint?

       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); } } }

    * 要创建普通内部类，必须先创建相应的外部类：

    view plaincopy to clipboardprint?

       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(); } }
    也可以用下面的方式：

    view plaincopy to clipboardprint?

       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++的嵌套类，与普通内部类相比有如下区别：

        *
          静态内部类没有指向外部类的引用，外部类对于它来说更像一个名字空间。
        *
          普通内部类不能有静态成员，静态方法，或另一个静态内部类；而静态内部类可以有这一切。
        *
          静态内部类可以直接创建，不必先创建外部类：

        view plaincopy to clipboardprint?

           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可以把一个类定义在一个方法里面，甚至是一个{}块里面，它的作用域就在这个块里面：
    
    view plaincopy to clipboardprint?

       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(); } }
    局部内部类的一般用途是实现某个接口，并作为这个接口传出方法被使用：
    
    view plaincopy to clipboardprint?

       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.  匿名内部类

    匿名内部类的语法如下：
    
    view plaincopy to clipboardprint?

       1. new InterfaceName(){......}; 或 new SuperclassName(){......};  

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

       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"); } }); } }