java内部类——转

本文原网址为：http://www.iteye.com/topic/442435，本文只对其中部分信息进行了摘录和加工。

内部类详解 
一、定义 
  一个类的定义放在另一个类的内部，这个类就叫做内部类。 

 public class First {
    public class Contents{
        public void f(){
        System.out.println("In Class First's inner Class Contents method f()");
        }
    }
  }

像这样的，Contents就叫做内部类 ，内部类了解外围类，并能与之通信(后面详细讲) 。

二、作用

1.链接到外围类 
  创建了内部类对象时，它会与创造它的外围对象有了某种联系，于是能访问外围类的所有成员，不需任何特殊条件。 

    public class First {
    public class Contents{
          public void getStr(){
            System.out.println("First.str="+str);
         }
    }
    private String str;
     }
  

在内部类Contents中，可以使用外围类First的字段str。 那么，它是如何实现的呢？ 
是这样的，用外围类创建内部类对象时，此内部类对象会秘密的捕获一个指向外围类的引用，于是，可以通过这个引用来访问外围类的成员。 

通常，这些都是编译器来处理，我们看不到，也不用关心这个。 正是因为如此，我们创建内部类对象时，必须与外围类对象相关联。 
 注：嵌套类(后面会讲到)除外。

个人理解：内部类的第一个比较重要的功能：模拟闭包；因为可以通过内部类连接其外围类的环境，这就是闭包的定义。 

2.隐藏实现细节

内部类与向上转型 ——将内部类向上转型为基类型，尤其是接口时，内部类就有了用武之地。

     public interface Shape {
    public void paint();
     }
     public class Painter {
     
        private class InnerShape implements Shape{
        public void paint(){
            System.out.println("painter paint() method");
        }
    }
    
    public Shape getShape(){
        return new InnerShape();
    }   
     
        public static void main(String []args){
        Painter painter = new Painter();
        Shape shape = painter. getShape();
        shape.paint();
    }
     }
  

说明：此时，内部类是private的，除了它的外围类Painter以外，没人能访问。 这样private内部类给累的设计者提供了一种途径，通过这种方式可以完全阻止任何依赖于类型的编码，并完全隐藏实现的细节。

注意：这里说的是“完全隐藏细节”，如果将InnerShape写在外部单独成类，并在Painter 调用InnerShape构造方法也可以达到目的；但是这样一来还是多了一个InnerShape类那么它的一部分细节还是被开放了！并没有达到“完全隐藏”。 

3.实现多重继承

    public interface One {
    public void inOne();
    }
    public interface Two {
    public void inTwo();
    }
    //两个接口，用普通类就可实现多重继承
    public class CommonClass implements One,Two {
    public void inOne(){
        System.out.println("CommonClass inOne() method");
    }
    
    public void inTwo(){
        System.out.println("CommonClass inTwo() method");
    }
    }
    public abstract class Three {
    public abstract void inThree();
    }
    public abstract class Four {
    public abstract void inFour();
    }
    //两个抽象类，使用普通类无法实现多重继承
    
    //使用内部类可以实现
    public class Contents extends Three {
    public void inThree(){
        System.out.println("In Contents inThress() method");
    }
    
    public class InnerFour extends Four{
        public void inFour(){
            System.out.println("In Contents");
        }
        
    }
    }
  

4.嵌套类（静态内部类）

static的内部类就叫做嵌套类 
前面提到了很多次，嵌套类是个例外 
使用嵌套类时有两点需要注意： 
   a、创建嵌套类对象时，不需要外围类 
   b、在嵌套类中，不能像普通内部类一样访问外围类的非static成员 

   public class StaticClass {
    private int num;
    private static int sum = 2;
    private static class StaticInnerClass{
        public int getNum(){
        //只能访问sum，不能访问num
                return sum;
        }
    }
   }
   public class Test {
    public static void main(String [] args){
                //可以直接通过new来创建嵌套类对象
        StaticClass.StaticInnerClass inner = new StaticClass.StaticInnerClass();
        inner.getNum();
    }
   }
 

静态内部类的详细说明：　

另外有一篇文章也进行了较好的说明：http://hi.baidu.com/duizhe_memory/item/f69290d3552c5d3c2a35c7e9

在一个类中创建另外一个类，叫做成员内部类。这个成员内部类可以静态的（利用static关键字修饰），也可以是非静态的。由于静态的内部类在定义、使用的时候会有种种的限制。所以在实际工作中用到的并不多。 
　　在开发过程中，内部类中使用的最多的还是非静态地成员内部类。不过在特定的情况下，静态内部类也能够发挥其独特的作用。 

（1）静态内部类的使用目的 

　　在定义内部类的时候，可以在其前面加上一个权限修饰符static。此时这个内部类就变为了静态内部类。不过由于种种的原因，如使用上的限制等等因素(具体的使用限制，笔者在下面的内容中会详细阐述)，在实际工作中用的并不是很多。但是并不是说其没有价值。在某些特殊的情况下，少了这个静态内部类还真是不行。如在进行代码程序测试的时候，如果在每一个Java源文件中都设置一个主方法(主方法是某个应用程序的入口，必须具有)，那么会出现很多额外的代码。而且最主要的时这段主程序的代码对于Java文件来说，只是一个形式，其本身并不需要这种主方法。但是少了这个主方法又是万万不行的。在这种情况下，就可以将主方法写入到静态内部类中，从而不用为每个Java源文件都设置一个类似的主方法。这对于代码测试是非常有用的。在一些中大型的应用程序开发中，则是一个常用的技术手段。为此，这个静态内部类虽然不怎么常用，但是程序开发人员还必须要掌握它。也许在某个关键的时刻，其还可以发挥巨大的作用也说不定。 

（2）静态内部类的使用限制。 

　　将某个内部类定义为静态类，跟将其他类定义为静态类的方法基本相同，引用规则也基本一致。不过其细节方面仍然有很大的不同。具体来说，主要有如下几个地方要引起各位程序开发人员的注意。 

　　一是静态成员(包括静态变量与静态成员)的定义。一般情况下，如果一个内部类不是被定义成静态内部类，那么在定义成员变量或者成员方法的时候，是不能够被定义成静态成员变量与静态成员方法的。也就是说，在非静态内部类中不可以声明静态成员。如现在在一个student类中定义了一个内部类age，如果没有将这个类利用static关键字修饰，即没有定义为静态类，那么在这个内部类中如果要利用static关键字来修饰某个成员方法或者成员变量是不允许的。在编译的时候就通不过。故程序开发人员需要注意，只有将某个内部类修饰为静态类，然后才能够在这个类中定义静态的成员变量与成员方法。这是静态内部类都有的一个特性。也正是因为这个原因，有时候少了这个静态的内部类，很多工作就无法完成。或者说要绕一个大圈才能够实现某个用户的需求。这也是静态的内部类之所以要存在的一个重要原因。 

　　二是在成员的引用上，有比较大的限制。一般的非静态内部类，可以随意的访问外部类中的成员变量与成员方法。即使这些成员方法被修饰为private(私有的成员变量或者方法)，其非静态内部类都可以随意的访问。则是非静态内部类的特权。因为在其他类中是无法访问被定义为私有的成员变量或则方法。但是如果一个内部类被定义为静态的，那么在银用外部类的成员方法或则成员变量的时候，就会有诸多的限制。如不能够从静态内部类的对象中访问外部类的非静态成员(包括成员变量与成员方法)。这是什么意思呢?如果在外部类中定义了两个变量，一个是非静态的变量，一个是静态的变量。那么在静态内部类中，无论在成员方法内部还是在其他地方，都只能够引用外部类中的静态的变量，而不能够访问非静态的变量。在静态内部类中，可以定义静态的方法(也只有在静态的内部类中可以定义静态的方法)，在静态方法中引用外部类的成员。但是无论在内部类的什么地方引用，有一个共同点，即都只能够引用外部类中的静态成员方法或者成员变量。对于那些非静态的成员变量与成员方法，在静态内部类中是无法访问的。这就是静态内部类的最大使用限制。在普通的非静态内部类中是没有这个限制的。也正是这个原因，决定了静态内部类只应用在一些特定的场合。其应用范围远远没有像非静态的内部类那样广泛。 

　三是在创建静态内部类时不需要将静态内部类的实例绑定在外部类的实例上。 

      通常情况下，在一个类中创建成员内部类的时候，有一个强制性的规定，即内部类的实例一定要绑定在外部类的实例中。也就是说，在创建内部类之前要先在外部类中要利用new关键字来创建这个内部类的对象。如此的话如果从外部类中初始化一个内部类对象，那么内部类对象就会绑定在外部类对象上。也就是说，普通非静态内部类的对象是依附在外部类对象之中的。但是，如果成员开发人员创建的时静态内部类，那么这就又另当别论了。通常情况下，程序员在定义静态内部类的时候，是不需要定义绑定在外部类的实例上的。也就是说，要在一个外部类中定义一个静态的内部类，不需要利用关键字new来创建内部类的实例。即在创建静态类内部对象时，不需要其外部类的对象。具体为什么会这样，一般程序开发人员不需要了解这么深入，只需要记住有这个规则即可。在定义静态内部类的时候，千万不要犯画蛇添足的错误。 

　　从以上的分析中可以看出，静态内部类与非静态的内部类还是有很大的不同的。一般程序开发人员可以这么理解，非晶态的内部类对象隐式地在外部类中保存了一个引用，指向创建它的外部类对象。不管这么理解，程序开发人员都需要牢记静态内部类与非静态内部类的差异。如是否可以创建静态的成员方法与成员变量(静态内部类可以创建静态的成员而非静态的内部类不可以)、对于访问外部类的成员的限制(静态内部类只可以访问外部类中的静态成员变量与成员方法而非静态的内部类即可以访问静态的也可以访问非静态的外部类成员方法与成员变量)。这两个差异是静态内部类与非静态外部类最大的差异，也是静态内部类之所以存在的原因。了解了这个差异之后，程序开发人员还需要知道，在什么情况下该使用静态内部类。如在程序测试的时候，为了避免在各个Java源文件中书写主方法的代码，可以将主方法写入到静态内部类中，以减少代码的书写量，让代码更加的简洁。 

　　总之，静态内部类在Java语言中是一个很特殊的类，跟普通的静态类以及非静态的内部类都有很大的差异。作为程序开发人员，必须要知道他们之间的差异，并在实际工作中在合适的地方采用合适的类。不过总的来说，静态内部类的使用频率并不是很高。但是在有一些场合，如果没有这个内部静态类的话，可能会起到事倍功半的反面效果 

 

（3）嵌套类在测试中的应用

静态内部类在概念和实现上都十分简单，基本上来说就是在您的主类中定义一个静态类：   
  public   class   Foo   
  {   
  //   ....   
  public   static   class   Test   
  {   
  public   static   void   main   (String[]   args)   
  {   
  //   ....   
  }   
  }   
  }   
  说到向您主要的类中添加辅助代码，其中最重要的一点就是静态内部类被编译到一个单独的   .class   文件中，这个文件独立于它的外部类。例如，如果外部类叫做   Foo，而它的一个内部类叫   Test，那么这个内部类将被编译成   Foo$Test.class   文件。.class   文件的分离意味着您可以将辅助的嵌套代码与主要的外部类牢固地捆绑在一起。它们在同一个源文件中，内部类的确是在外部类的   内部。您无需再付出任何发布或运行时的开销。真棒！例如，如果辅助代码只是用于调试，那么您只需发布   Foo.class   文件而将   Foo$Test.class   文件留下即可。   
  我将这个技巧主要用于编写外部类的演示代码、错误调试代码，以及进行单元测试实现类行为的自动验证。（当然，做为一个勤奋的开发人员，我准备将测试代码转化成单元测试。）   
  注意，要执行   Foo.Test   类的   main()   方法，请使用下面的命令：   
  %   java   Foo$Test   
  如果您正在使用的命令解释程序（shell）把“$”做为一个保留字，那么您应该使用下面的命令：   
  %   java   Foo\$Test   
  还有一点十分有趣：静态内部类根据定义可以访问外部类的保护域和私有域。这件事可以说既有利也有弊。因为您可能在不经意间就破坏了外部类的保护域和私有域，从而违反了它的封装性，所以请小心对待！这一功能最恰当的应用就是编写类的   白盒测试程序－－因为这样可以引入一些利用通常的黑盒测试很难引入的问题（黑盒测试不能访问对象的内部状态）。   
  XYPair   类十分简单。它提供一个固定的整数对，（x，y）。XYPair.Test   类有一个   main()   方法可以对   XYPair   进行简单的测试并输出结果。试着调整测试代码和核心代码来试验各种可能的问题。   
  如果您更加大胆，您可能想检验   Java   单元测试构架（JUnit）。您可以去掉源代码中的各种注释，然后利用   JUnit   的测试引擎运行这些测试程序。   
  结论   
  通过使用静态内部类，您可以给您的系统添加辅助功能，以便完成诸如测试之类的工作，而对正式发布的产品不会带来任何不利影响。