java内部类解析及应用场景简介

https://blog.csdn.net/kx_nullpointer/article/details/7744839

转自：http://blog.csdn.net/historyasamirror/article/details/6049073

所谓内部类，就是一个类的定义放在了另一个类定义的内部，如：

[java]  view plain copy

1. public class OuterClass {  
2.     private int outerData;  
3.     // .....  
4.     public class InnerClass {  
5.         private int innerData;  
6.         // ......  
7.     }  
8. }  

内部类应该算得上是Java学习过程中的一个难点了。它之所以难，我觉着有两个方面：一是它的语法相比于Java其它部分要显得繁琐，有很多需要注意的细节； 二是它的应用场景，即为什么Java需要这么一个东西，它到底能够带来什么样的好处？如果不能回答这个问题，那么即便熟悉了它的相关语法，也很难在今后的实践中使用它。而在我个人的学习过程中，第二点更加长久的困扰了我。

这篇blog也主要是围绕着这两个难点展开的。

为了便于理解，我将所有内部类中和static有关的部分全部放在了整片文章的结尾。所以，一开始可以暂时将这些内容置之不理。最后，我会解释为什么要这么做。

 

先解释一些和语法相关的内容。

 

正如前面的代码所展现的那样，内部类是在某一个类的内部所定义的。这样的话，它至少有两点和普通的class不太一样：

1. 它体现了一种代码的隐藏机制和访问控制机制。在这一点上，它很像是C++的嵌套类的概念；

2. 它包含有一个外部类的this指针。这是理解内部类特性非常重要的一点。正是由于有了这个指针，内部类可以访问外部类的所有元素。

将这两点结合到一起，就是内部类的本质了。

 

针对1. 的补充：

如果内部类被声明为public ，那么外部类作用域之外的地方是可以使用这个类名的，但是使用的方法必须是：

        OuterClass.InnerClass

这其实就有点命名空间的意思了。要用InnerClass，可以啊，但永远都得前面带着个前缀...

而想创建这样的内部类的实例，则需要使用一个外部类的实例。比如如果有一个OuterClass的实例，OuterObject:
    OuterClass.InnerClass InnerObject = OuterObject.new InnerClass();

这样，就可以在外部类作用域以外的地方得到一个内部类的实例了。而之所以需要这样做的原因，就在于内部类的实例必须含有一个外部类的this指针，如果不是先有一个外部类实例，哪来的这个this指针呢？

如果内部类被声明为private ：

首先一点，在Java中，普通的类是不能被private修饰的。所以，只有内部类能够被private所修饰；

其次，如果被修饰成了private，那么内部类在外部类作用域之外的地方就不可见了。只有外部类能够使用内部类。这样，就实现了一种访问控制。

 

针对2. 的补充：

所谓可以访问外部类的所有元素，即包括了外部类的public/private的所有成员数据和方法。比如前面的代码，InnerClass是可以改变OuterClass的那个outerData的：

[java]  view plain copy

1. public class OuterClass {  
2.     private int outerData;  
3.     public class InnerClass {  
4.         private void func() {  
5.             OuterClass.this.outerData = 1;  
6.             // ..........  
7.         }      
8.    }  
9. }  

另一方面，反向的，外部类对于内部类的所有元素也都有访问权，包括内部类的私有成员和方法：

[java]  view plain copy

1. public class OuterClass {  
2.       
3.     public class InnerClass {  
4.         private int innerData;  
5.         // .....  
6.     }  
7.     public void func() {  
8.         InnerClass innerObj = new InnerClass();  
9.         innerObj.innerData = 0;  
10.         // .........  
11.     }  
12. }  

 

内部类的一种特殊的情况就是所谓的局部内部类，即在某个类的成员函数中定义内部类：

[java]  view plain copy

1. public class OuterClass {  
2.       
3.     public void func() {  
4.         class InnerClass {  
5.             private int innerData;  
6.               
7.             //.....  
8.         }  
9.           
10.         InnerClass innerObj = new InnerClass();  
11.           
12.         //.....  
13.     }  
14. }  

以前面介绍的内部类的两个特性来看待局部内部类：从访问控制上看，局部内部类不能够用public或者private来修饰，它只在这个成员方法内可见；从和外部类的联系上看，它和普通的内部类没有太大差别，都可以访问外部类的任意元素。唯一的区别在于，它还可以访问这个成员方法中的局部变量，只要这个局部变量被声明成final （这是个语法细节，我不展开说了）。

 

说了这么多语法了，可还是看不出内部类到底有什么用。所以接下来，先介绍一个内部类常用的一个场景，即内部类继承某个接口或者基类。而外部类的某个成员方法可以创建一个内部类的实例，然后将这个实例向上转型为它的接口/基类，例如：

[java]  view plain copy

1. //: BaseIF.java  
2. public interface BaseIF {  
3.     //.....  
4. }  
5. //: OuterClass.java  
6. public class OuterClass {  
7.       
8.     public BaseIF getBase() {  
9.         class InnerClass implements BaseIF {  
10.             //.......  
11.         }  
12.           
13.         return new InnerClass();  
14.     }  
15.       
16.     public static void main(String[] args) {  
17.         OuterClass outerObj = new OuterClass();  
18.         BaseIF base = outerObj.getBase();  
19.     }  
20. }  

在最后的main函数中，一个外部类的实例outerObj，通过调用它的一个成员函数.getBase()，最后我们获得了一个BaseIF这个接口的实例。但其实这个实例是一个内部类InnerClass，InnerClass在外部类之外是不可见的，但由于它是BaseIF的实现，所以我们仍然能够将它的实例作为返回值抛出来，然后向上转型成BaseIF来操作。

当然，现在这个例子，仍然看不懂内部类到底有什么大用处，别急，接着往下走。

 

正是由于内部类频繁的被用于这样的场景，所以又发明了一种针对这种场景的更简单的内部类，匿名内部类：

[java]  view plain copy

1. //. BaseIF.java  
2. public interface BaseIF {  
3.     //.....  
4.     public void func();  
5. }  
6. //. OuterClass.java  
7. public class OuterClass {  
8.       
9.     public BaseIF getBase() {  
10.         return new BaseIF() {  
11.             public void func() {  
12.                 //.......  
13.             }  
14.         };  
15.     }  
16.       
17.     public static void main(String[] args) {  
18.         OuterClass outerObj = new OuterClass();  
19.         BaseIF base = outerObj.getBase();  
20.     }  
21. }  

任何一个第一次看见这种代码的人一定会郁闷的，比如我。而任何一个试图去读懂这个代码的人一定会郁闷很久的，比如我。

但如果了解到之前的那个应用场景的话，那么这段代码就算是比较易懂了：

“return new BaseIF”这行代码，说明是要返回一个BaseIF的对象，而之后又出现了一对"{}"，说明这对大括号里面就是一个匿名内部类，这个类实现了BaseIF（如果BaseIF不是接口而是一个基类，那么就不是实现而是继承）。大括号中的"public void func"是重新实现了BaseIF的成员函数；

而之所以称为匿名，是因为这个类确实没有名字，我们唯一能知道的就是它实现了BaseIF；

 

到此为止，大部分内部类的语法知识都说完了。但是，最重要的那个问题仍然没有被回答：为什么Java要费力的加入这么一个特性，它到底能够提供什么样的好处？

如果搜索网上的文章，那么你大概能找到这么一个答案：内部类能够帮助Java实现回调，进一步说，它适用于事件驱动的架构。但这么一个答案，仍然很难理解。

为了解释清楚这件事，先从一个最简单的事件驱动的程序开始：

[java]  view plain copy

1. // EventIF.java  
2. public interface EventIF {  
3.     public void execute();  
4. }  
5. // Controller.java  
6. public class Controller {  
7.     public void addEvent(EventIF event) {  
8.         //.......  
9.         event.execute();  
10.         //......  
11.     }  
12. }  

一旦某个event被添加进了Controller中，Controller就会调用event的execute方法。

 

接下来，看看怎样能够去实例化一些event。一个直接的办法就是创建一些新的类，这些类是EventIF的实现，比如：

[java]  view plain copy

1. // Event1.java  
2. public class Event1 implements EventIF {  
3.       
4.     public void execute() {  
5.         System.out.println("this is Event1");  
6.     }  
7. }  
8. //Controller.java  
9. public class Controller {  
10.         // ...........  
11.     public static void main(String[] args) {  
12.         Controller contler = new Controller();  
13.         contler.addEvent(new Event1());  
14.     }  
15. }  

 

毫无疑问，这样做没有问题。我们可以创建一个Event1的实例，然后将它作为addEvent()的参数加入到controller中。

 

但是，这样做也意味着，任何一个类如果希望成为event能够被controller所调用，那么它必须是EventIF的实现。首先，这么做不一定合适。此外，如果Event1不是接口而是基类，那么对于某些已经继承了其它基类的派生类，它们就不可能再去继承EventIF（因为Java不支持多重继承），所以这些类就不可能作为Event被controller调用了。

 

为了解决这个问题，内部类显示威力的时候到了：

[java]  view plain copy

1. // commonClass.java  
2. public class CommonClass {  
3.     // ......  
4.       
5.     public EventIF getBase() {  
6.         class Event2 implements EventIF {  
7.             public void execute() {  
8.                 System.out.println("this is Event2");  
9.             }  
10.         }  
11.           
12.         return new Event2();  
13.     }  
14. }