Java内部类详解（一）

（转自：http://blog.csdn.net/wangpeng047/article/details/12344593）

很多人对于Java内部类（Inner Class）都十分陌生，甚至听都没听过也没有使用过，内部类在Java中其实是比较重要的一块内容，掌握好这门知识对于编程来说，犹如插上一对翅膀。

一、概念

内部类是指在一个外部类的内部再定义一个类，类名不需要和文件名相同。

对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后会生成outer.class和outer$inner.class两个类。所以内部类的成员变量、方法名可以和外部类的相同。

内部类可以是静态static和非静态的，访问级别可用public，default，protected和private修饰。而外部*类即类名和文件名相同的只能使用public和default。

二、作用

为什么使用内部类？使用内部类能带来什么好处？

我们用个例子来说明：

1. public class Work {
2. public String getContent() {
3. return null;
4. }
5. }
6. public class Tool {
7. public void use() {
8. }
9. }
10. public class Person {
11. private String name;
12. public String getName() {
13. return name;
14. }
15. public void setName(String name) {
16. this.name = name;
17. }
18. public Work getWork() {
19. return new Work();
20. }
21. public Tool getTool() {
22. return new Tool();
23. }
24. }
25. public class Programmer extends Person {
26. private String language;
27. private class Programming extends Work {
28. @Override
29. public String getContent() {
30. return "搭建框架";
31. }
32. }
33. protected class Computer extends Tool {
34. private String soft;
35. @Override
36. public void use() {
37. this.soft = "Eclipse";
38. Programmer.this.language = this.soft + "工具中的Java语言";
39. }
40. }
41. public void doWork() {
42. getTool().use();
43. System.out.println(getName() + "用" + language + getWork().getContent());
44. }
45. @Override
46. public Work getWork() {
47. return new Programming();
48. }
49. @Override
50. public Tool getTool() {
51. return new Computer();
52. }
53. public static void main(String[] args) {
54. Programmer programmer = new Programmer();
55. programmer.setName("王鹏");
56. programmer.doWork();
57. }
58. }

运行结果：

1. 王鹏用Eclipse工具中的Java语言搭建框架

这个简单例子是描述一个程序员的工作，在现有Person、Tool、Work三个类的基础上，衍生出了程序员Programmer类。Programmer类中定义了内部类Programming和Computer，并且访问级别分别是private和protected。

1. 封装

通过上面例子的main方法中，我们看到，调用者并不知道Programming和Computer这两个内部类的存在，对外只暴漏了Programmer类。由于Programming和Computer只是为Programmer服务的，完全没必要单独建立个类文件，因而通过内部类我们可以隐藏掉不想让别人知道的操作。内部类是封装性的进一步体现。

2. 多继承

我们知道，Java是单继承语言，只能继承一个类，然而通过内部类，我们可以变相实现“多继承”。例如上面的例子中，Programming继承Work，Computer继承Tool，Programmer继承Person，而Programming和Computer是Programmer的内部类，因此就相当于Programmer继承了Person、Work、Tool这三个类，同样能实现多态，代码如下：

1. public class Programmer extends Person {
2. public class Programming extends Work {
3. public Person getPerson() {
4. return Programmer.this;
5. }
6. }
7. public class Computer extends Tool {
8. public Person getPerson() {
9. return Programmer.this;
10. }
11. }
12. }
13. public class ProgrammerTest {
14. private Programmer programmer;
15. public ProgrammerTest() {
16. programmer = new Programmer();
17. programmer.setName("王鹏");
18. }
19. public Work testWork() {
20. return programmer.new Programming();
21. }
22. public Tool testTool() {
23. return programmer.new Computer();
24. }
25. public Person testPerson() {
26. return programmer;
27. }
28. public static void main(String[] args) {
29. ProgrammerTest test = new ProgrammerTest();
30. Programmer programmer = (Programmer) test.testPerson();
31. System.out.println(programmer.getName());
32. Programmer.Computer computer = (Programmer.Computer) test.testTool();
33. programmer = (Programmer) computer.getPerson();
34. System.out.println(programmer.getName());
35. Programmer.Programming programming = (Programmer.Programming) test.testWork();
36. programmer = (Programmer) programming.getPerson();
37. System.out.println(programmer.getName());
38. // 方法入参的多态就不掩饰了,如testTool(Tool tool),可将Tool转化为Programmer
39. }
40. }

输出结果：

1. 王鹏
2. 王鹏
3. 王鹏

由上个例子可以看出，Person、Tool、Programming都可以转化为同一个Programmer，从而实现了“多继承”的多态体现。内部类是Java多继承的技术实现的手段。

Java内部类详解（二）

 

Java内部类详解（三）