首页 > 代码库 > Java内部类详解（一）（转自：http://blog.csdn.net/wangpeng047/article/details/12344593）

Java内部类详解（一）（转自：http://blog.csdn.net/wangpeng047/article/details/12344593）

2024-07-21 12:09:56   224人阅读

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

一、概念

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

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

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

二、作用

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

我们用个例子来说明：

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

运行结果：

[plain] view plaincopy
 
  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这三个类，同样能实现多态，代码如下：

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

输出结果：

[plain] view plaincopy
 
  1. 王鹏  
  2. 王鹏  
  3. 王鹏  

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

 

Java内部类详解（二）

 

 

Java内部类详解（三）

 

Java内部类详解（一）（转自：http://blog.csdn.net/wangpeng047/article/details/12344593）


联系
我们