JAVA内部类学习总结。

短命女 2022-08-13 03:59 188阅读 0赞

来源：[http://www.iteye.com/topic/442435][http_www.iteye.com_topic_442435]

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

Java代码 ![收藏代码][icon_star.png]

像这样的，Contents就叫做内部类   
内部类了解外围类，并能与之通信(后面详细讲)   
  
2、链接到外围类   
 创建了内部类对象时，它会与创造它的外围对象有了某种联系，于是能访问外围类的所有成员，不需任何特殊条件。

Java代码 ![收藏代码][icon_star.png]

1.  **public** **class** First \{ 
2.  **public** **class** Contents\{ 
3.  **public** **void** getStr()\{ 
4.   System.out.println("First.str="\+str); 
5.   \} 
6.  \} 
7.  **private** String str; 
8.   \} 
9.

在内部类Contents中，可以使用外围类First的字段str。   
 那么，它是如何实现的呢？   
 是这样的，用外围类创建内部类对象时，此内部类对象会秘密的捕获一个指向外围类的引用，于是，可以通过这个引用来访问外围类的成员。   
 通常，这些都是编译器来处理，我们看不到，也不用关心这个。   
 正是因为如此，我们创建内部类对象时，必须与外围类对象相关联。   
 注：嵌套类(后面会讲到)除外。   
  
3、使用关键字.this与.new   
 内部类中得到当前外围类对象的引用，可以使用.this关键字，注意与new的区别

Java代码 ![收藏代码][icon_star.png]

1.  **private** **int** num ; 
2.  **public** Test2()\{ 
3.  
4.  \} 
5.  
6.  **public** Test2(**int** num)\{ 
7.  **this**.num = num; 
8.  \} 
9.  
10. **private** **class** Inner\{ 
11. **public** Test2 getTest2()\{ 
12. **return** Test2.**this**; 
13.  \} 
14. 
15. **public** Test2 newTest2()\{ 
16. **return** **new** Test2(); 
17.  \} 
18. \} 
19. 
20. **public** **static** **void** main(String \[\] args)\{ 
21.  Test2 test = **new** Test2(5); 
22.  Test2.Inner inner = test.**new** Inner(); 
23.  Test2 test2 = inner.getTest2(); 
24.  Test2 test3 = inner.newTest2(); 
25.  System.out.println(test2.num); 
26.  System.out.println(test3.num); 
27. \} 
28.

输出结果为5 0   
 使用.this后，得到时创建该内部类时使用的外围类对象的引用，new则是创建了一个新的引用。   
  
 .new关键字   
 如果想直接创建一个内部类对象，而不是通过外围类对象的方法来得到，可以使用.new关键字   
 形式是这样的：

Java代码 ![收藏代码][icon_star.png]

1.  OutClass.InnerClass obj = outClassInstance.**new** InnerClass();

必须是外围类对象.new，而不能是外围类.new

Java代码 ![收藏代码][icon_star.png]

1.  **public** **class** First \{ 
2.  **public** **class** Contents\{ 
3.  **public** **void** f()\{ 
4.   System.out.println("In Class First's inner Class Contents method f()"); 
5.   \} 
6.  **public** **void** getStr()\{ 
7.   System.out.println("First.str="\+str); 
8.   \} 
9.  \} 
10. 
11. **public** **static** **void** main(String \[\] args)\{ 
12.  First first = **new** First(); 
13.  First.Contents contents = first.**new** Contents(); 
14.  contents.f(); 
15. \} 
16.  \} 
17.

必须通过外围类First的对象first来创建一个内部类的对象   
 而且需要注意的是，在创建外围类对象之前，不可能创建内部类的对象(嵌套类除外)。   
4、内部类与向上转型   
 将内部类向上转型为基类型，尤其是接口时，内部类就有了用武之地。

Java代码 ![收藏代码][icon_star.png]

1.  **public** **interface** Shape \{ 
2.  **public** **void** paint(); 
3.   \} 
4.  **public** **class** Painter \{ 
5.  
6.  **private** **class** InnerShape **implements** Shape\{ 
7.  **public** **void** paint()\{ 
8.   System.out.println("painter paint() method"); 
9.   \} 
10. \} 
11. 
12. **public** Shape getShape()\{ 
13. **return** **new** InnerShape(); 
14. \} 
15. 
16. **public** **static** **void** main(String \[\]args)\{ 
17.  Painter painter = **new** Painter(); 
18.  Shape shape = painter. getShape(); 
19.  shape.paint(); 
20. \} 
21.  \} 
22.

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

Java代码 ![收藏代码][icon_star.png]

1.  **public** **void** test()\{ 
2.  ass Inner\{ 
3.  **public** **void** method()\{ 
4.  ystem.out.println("在方法内创建的类"); 
5.   \} 
6.  
7.  \}

值得注意的是：方法内创建的类，不能加访问修饰符。   
 另外，方法内部的类也不是在调用方法时才会创建的，它们一样也被编译了(怎么知道的？后面会有讲解)。   
  
6、匿名内部类

Java代码 ![收藏代码][icon_star.png]

1.  **public** **class** Painter \{ 
2.  ublic Shape getShape()\{ 
3.  **return** **new** Shape()\{ 
4.  **public** **void** paint()\{ 
5.   System.out.println("painter paint() method"); 
6.   \} 
7.  \}; 
8.  
9.  **public** **static** **void** main(String \[\] args)\{ 
10.  Painter painter = **new** Painter(); 
11.  Shape shape = painter.getShape(); 
12.  shape.paint(); 
13.  \} 
14.  \} 
15. **public** **interface** Shape \{ 
16. ublic **void** paint(); 
17.  \}

注意，匿名内部类后面的分号不可缺少！   
 匿名类，顾名思义，就是没有名称。   
 getShape（）方法里，就使用了匿名内部类。   
 看上去很奇怪，不符合传统的写法？   
 第一眼看上去确实是这样的。   
  
 这样写，意思是创建了一个实现了Shape的匿名类的对象。   
 匿名类可以创建，接口，抽象类，与普通类的对象。创建接口时，必须实现接口中所有方法。   
  
 这是无参的，如果需要参数呢？   
 可以直接传。

Java代码 ![收藏代码][icon_star.png]

1.  **public** **class** B \{ 
2.  **public** A getA(**int** num)\{ 
3.  **return** **new** A(num)\{ 
4.  
5.   \}; 
6.  \} 
7.   \} 
8.  **public** **class** A \{ 
9.  **private** **int** num; 
10. **public** A(**int** num)\{ 
11. **this**.num = num; 
12. \} 
13. **public** A()\{ 
14. 
15. \} 
16.  \} 
17.

Ok，在这个例子中，可以为A的构造方法传入一个参数。在匿名内部类中，并没有使用到这个参数。   
 如果使用到了这个参数，那么这个参数就必须是final的。

Java代码 ![收藏代码][icon_star.png]

1.  **public** **class** B \{ 
2.  **public** A getA(**final** **int** num)\{ 
3.  **return** **new** A(num)\{ 
4.  **public** **int** getNum()\{ 
5.  **return** num; 
6.   \} 
7.   \}; 
8.  \} 
9.   \} 
10. **public** **class** A \{ 
11. **private** **int** num; 
12. **public** A(**int** num)\{ 
13. **this**.num = num; 
14. \} 
15. **public** A()\{ 
16. 
17. \} 
18.  \} 
19.

如果不是final的，编译器就会提示出错。   
 另外，还可以在匿名内部类里定义属性   
 由于类是匿名的，自然没有构造器，如果想模仿构造器，可以采用实例初始化(\{\})

Java代码 ![收藏代码][icon_star.png]

1.  **public** A getA()\{ 
2.  **return** **new** A()\{ 
3.  **int** num = 0; 
4.   String str; 
5.   \{ 
6.   str = "javaeye"; 
7.   System.out.println("hello robbin"); 
8.   \} 
9.  \}; 
10.  \} 
11.

匿名内部类通过实例初始化，可以达到类似构造器的效果~   
  
另外可以通过匿名内部类来改造工厂方法。

Java代码 ![收藏代码][icon_star.png]

1.  **public** **interface** Service \{ 
2.  **public** **void** method1(); 
3.   \} 
4.  **public** **interface** ServiceFactory \{ 
5.  Service getService(); 
6.   \} 
7.  **public** **class** Implemention1 **implements** Service\{ 
8.  **public** **void** method1()\{ 
9.   System.out.println("In Implemention1 method method1()"); 
10. \} 
11. 
12. **public** **static** ServiceFactory factory = **new** ServiceFactory()\{ 
13. **public** Service getService()\{ 
14. **return** **new** Implemention1(); 
15.  \} 
16. \}; 
17.  \} 
18. **public** **class** Implemention2 **implements** Service \{ 
19. **public** **void** method1()\{ 
20.  System.out.println("in Implemention2 method method1()"); 
21. \} 
22. 
23. **public** **static** ServiceFactory factory = **new** ServiceFactory()\{ 
24. **public** Service getService()\{ 
25. **return** **new** Implemention2(); 
26.  \} 
27. \}; 
28. 
29.  \} 
30. **public** **class** Test \{ 
31. **public** **static** **void** main(String \[\]args)\{ 
32.  service(Implemention1.factory); 
33.  service(Implemention2.factory); 
34. 
35.  ServiceFactory factory1 = Implemention1.factory; 
36.  Service service1 = factory1.getService(); 
37.  service1.method1(); 
38. 
39.  ServiceFactory factory2 = Implemention1.factory; 
40.  Service service2 = factory2.getService(); 
41.  service2.method1(); 
42. \} 
43.  \}

在Implemention1和2中匿名内部类用在字段初始化地方。   
这样定义的工厂方法，代码上看起来是不是优雅一些？ ![icon_redface.gif][]   
  
7、嵌套类   
static的内部类就叫做嵌套类   
前面提到了很多次，嵌套类是个例外   
使用嵌套类时有两点需要注意：   
 a、创建嵌套类对象时，不需要外围类   
 b、在嵌套类中，不能像普通内部类一样访问外围类的非static成员

Java代码 ![收藏代码][icon_star.png]

1.  **public** **class** StaticClass \{ 
2.  **private** **int** num; 
3.  **private** **static** **int** sum = 2; 
4.  **private** **static** **class** StaticInnerClass\{ 
5.  **public** **int** getNum()\{ 
6.  //只能访问sum，不能访问num
7.  **return** sum; 
8.   \} 
9.  \} 
10.  \} 
11. **public** **class** Test \{ 
12. **public** **static** **void** main(String \[\] args)\{ 
13. //可以直接通过new来创建嵌套类对象
14.  StaticClass.StaticInnerClass inner = **new** StaticClass.StaticInnerClass(); 
15.  inner.getNum(); 
16. \} 
17.  \}

另外，嵌套类还有特殊之处，就是嵌套类中可以有static方法，static字段与嵌套类，而普通内部类中不能有这些。   
  
 8、内部类标识符   
 我们知道每个类会产生一个.class文件，文件名即为类名   
 同样，内部类也会产生这么一个.class文件，但是它的名称却不是内部类的类名，而是有着严格的限制：外围类的名字，加上$,再加上内部类名字。   
 前面说到得定义在方法内的内部类，不是在调用方法时生成，而是与外围类一同编译，就可以通过查看.class文件的方式来证明。   
  
 9、为何要内部类？   
 a、内部类提供了某种进入外围类的窗户。   
 b、也是最吸引人的原因，每个内部类都能独立地继承一个接口，而无论外围类是否已经继承了某个接口。   
 因此，内部类使多重继承的解决方案变得更加完整。   
 在项目中，需要多重继承，如果是两个接口，那么好办，接口支持多重继承。   
 如果是两个类呢？这时只有使用内部类了。

Java代码 ![收藏代码][icon_star.png]

1.  **public** **interface** One \{ 
2.  **public** **void** inOne(); 
3.   \} 
4.  **public** **interface** Two \{ 
5.  **public** **void** inTwo(); 
6.   \} 
7.  //两个接口，用普通类就可实现多重继承
8.  **public** **class** CommonClass **implements** One,Two \{ 
9.  **public** **void** inOne()\{ 
10.  System.out.println("CommonClass inOne() method"); 
11. \} 
12. 
13. **public** **void** inTwo()\{ 
14.  System.out.println("CommonClass inTwo() method"); 
15. \} 
16.  \} 
17. **public** **abstract** **class** Three \{ 
18. **public** **abstract** **void** inThree(); 
19.  \} 
20. **public** **abstract** **class** Four \{ 
21. **public** **abstract** **void** inFour(); 
22.  \} 
23. //两个抽象类，使用普通类无法实现多重继承
24. 
25. //使用内部类可以实现
26. **public** **class** Contents **extends** Three \{ 
27. **public** **void** inThree()\{ 
28.  System.out.println("In Contents inThress() method"); 
29. \} 
30. 
31. **public** **class** InnerFour **extends** Four\{ 
32. **public** **void** inFour()\{ 
33.  System.out.println("In Contents"); 
34.  \} 
35. 
36. \} 
37.  \} 
38.

另外，还有好多地方可以使用内部类。读过hibernate源代码的同学，应该可以发现，里面有好多内部类。   
 最常见的内部类，应该是Map.Entry了，可以看看源代码~

备注：

1.不允许在外部类的静态成员中直接使用非静态内部类

2.非静态内部类里不能有静态方法，静态属性，静态初始化块

3.static 修饰的内部类成为类得内部类，static关键字的作用是把类得成员变成相关，而不是实例相关，即static修饰成员是属于整个类，而不是属于单个对象的外部类。外部类的上一级程序单元式包，所以不能用static修饰，而内部类的上一级是外部类，使用static修饰可以将内部类变成外部类相关，而不是外部类实例相关。

4.静态内部类不能访问外部类的实例成员，只能访问外部类的类成员，即使静态内部类的实例方法，也不能访问外部类的实例成员，只能访问外部类的静态成员。

5.静态内部类是外部类的一个静态成员，因此外部类的静态方法，静态初始化块可以使用内部类定义变量，创建对象等。

[http_www.iteye.com_topic_442435]: http://www.iteye.com/topic/442435
[icon_star.png]: /images/20220810/560cc7767c004dd3a844b6f805f1c166.png
[icon_redface.gif]: /images/20220810/d08ba299200545cfbc8f0ec541af4abf.png