可以將一個類的定義放在另一個類的定義內部，這就是內部類。

內部類是一個非常有用的特性但又比較難理解使用的特性(鄙人到現在都沒有怎麽使用過內部類，對內部類也只是略知一二)。

第一次見面

內部類我們從外面看是非常容易理解的，無非就是在一個類的內部在定義一個類。

 1 public class OuterClass {
 2     private String name ;
 3     private int age;
 4 
 5     public String getName() {
 6         return name;
 7     }
 8 
 9
 
     public void setName(String name) {
10         this.name = name;
11     }
12 
13     public int getAge() {
14         return age;
15     }
16 
17     public void setAge(int age) {
18         this.age = age;
19     }
20     
21     class InnerClass{
22         public InnerClass(){
23             name = "chenssy";
 
24             age = 23;
25         }
26     }
27 }

在這裏InnerClass就是內部類，對於初學者來說內部類實在是使用的不多，鄙人菜鳥一個同樣沒有怎麽使用過(貌似僅僅只在做swing 註冊事件中使用過)，但是隨著編程能力的提高，我們會領悟到它的魅力所在，它可以使用能夠更加優雅的設計我們的程序結構。在使用內部類之間我們需要明白為什麽要使用內部類，內部類能夠為我們帶來什麽樣的好處。

一、為什麽要使用內部類

為什麽要使用內部類？在《Think in java》中有這樣一句話：使用內部類最吸引人的原因是：每個內部類都能獨立地繼承一個（接口的）實現，所以無論外圍類是否已經繼承了某個（接口的）實現，對於內部類都沒有影響。

在我們程序設計中有時候會存在一些使用接口很難解決的問題，這個時候我們可以利用內部類提供的、可以繼承多個具體的或者抽象的類的能力來解決這些程序設計問題。可以這樣說，接口只是解決了部分問題，而內部類使得多重繼承的解決方案變得更加完整。

 1 public interface Father {
 2 
 3 }
 4 
 5 public interface Mother {
 6 
 7 }
 8 
 9 public class Son implements Father, Mother {
10 
11 }
12 
13 public class Daughter implements Father{
14 
15     class Mother_ implements Mother{
16         
17     }
18 }

其實對於這個實例我們確實是看不出來使用內部類存在何種優點，但是如果Father、Mother不是接口，而是抽象類或者具體類呢？這個時候我們就只能使用內部類才能實現多重繼承了。

其實使用內部類最大的優點就在於它能夠非常好的解決多重繼承的問題，但是如果我們不需要解決多重繼承問題，那麽我們自然可以使用其他的編碼方式，但是使用內部類還能夠為我們帶來如下特性（摘自《Think in java》）：

1、內部類可以用多個實例，每個實例都有自己的狀態信息，並且與其他外圍對象的信息相互獨立。

2、在單個外圍類中，可以讓多個內部類以不同的方式實現同一個接口，或者繼承同一個類。

3、創建內部類對象的時刻並不依賴於外圍類對象的創建。

4、內部類並沒有令人迷惑的“is-a”關系，他就是一個獨立的實體。

5、內部類提供了更好的封裝，除了該外圍類，其他類都不能訪問。

二、內部類基礎

在這個部分主要介紹內部類如何使用外部類的屬性和方法，以及使用.this與.new。

當我們在創建一個內部類的時候，它無形中就與外圍類有了一種聯系，依賴於這種聯系，它可以無限制地訪問外圍類的元素。

 1 public class OuterClass {
 2     private String name ;
 3     private int age;
 4 
 5     /**省略getter和setter方法**/
 6     
 7     public class InnerClass{
 8         public InnerClass(){
 9             name = "chenssy";
10             age = 23;
11         }
12         
13         public void display(){
14             System.out.println("name：" + getName() +"   ;age：" + getAge());
15         }
16     }
17     
18     public static void main(String[] args) {
19         OuterClass outerClass = new OuterClass();
20         OuterClass.InnerClass innerClass = outerClass.new InnerClass();
21         innerClass.display();
22     }
23 }
24 --------------
25 Output：
26 name：chenssy   ;age：23

在這個應用程序中，我們可以看到內部了InnerClass可以對外圍類OuterClass的屬性進行無縫的訪問，盡管它是private修飾的。這是因為當我們在創建某個外圍類的內部類對象時，此時內部類對象必定會捕獲一個指向那個外圍類對象的引用，只要我們在訪問外圍類的成員時，就會用這個引用來選擇外圍類的成員。

其實在這個應用程序中我們還看到了如何來引用內部類：引用內部類我們需要指明這個對象的類型：OuterClasName.InnerClassName。同時如果我們需要創建某個內部類對象，必須要利用外部類的對象通過.new來創建內部類：

OuterClass.InnerClass innerClass = outerClass.new InnerClass();。

同時如果我們需要生成對外部類對象的引用，可以使用OuterClassName.this，這樣就能夠產生一個正確引用外部類的引用了。當然這點實在編譯期就知曉了，沒有任何運行時的成本。

 1 public class OuterClass {
 2     public void display(){
 3         System.out.println("OuterClass...");
 4     }
 5     
 6     public class InnerClass{
 7         public OuterClass getOuterClass(){
 8             return OuterClass.this;
 9         }
10     }
11     
12     public static void main(String[] args) {
13         OuterClass outerClass = new OuterClass();
14         OuterClass.InnerClass innerClass = outerClass.new InnerClass();
15         innerClass.getOuterClass().display();
16     }
17 }
18 -------------
19 Output:
20 OuterClass...

到這裏了我們需要明確一點，內部類是個編譯時的概念，一旦編譯成功後，它就與外圍類屬於兩個完全不同的類（當然他們之間還是有聯系的）。對於一個名為OuterClass的外圍類和一個名為InnerClass的內部類，在編譯成功後，會出現這樣兩個class文件：OuterClass.class和OuterClass$InnerClass.class。

在Java中內部類主要分為成員內部類、局部內部類、匿名內部類、靜態內部類。

三、成員內部類

成員內部類也是最普通的內部類，它是外圍類的一個成員，所以他是可以無限制的訪問外圍類的所有 成員屬性和方法，盡管是private的，但是外圍類要訪問內部類的成員屬性和方法則需要通過內部類實例來訪問。

在成員內部類中要註意兩點，第一：成員內部類中不能存在任何static的變量和方法；第二：成員內部類是依附於外圍類的，所以只有先創建了外圍類才能夠創建內部類。

 1 public class OuterClass {
 2     private String str;
 3     
 4     public void outerDisplay(){
 5         System.out.println("outerClass...");
 6     }
 7     
 8     public class InnerClass{
 9         public void innerDisplay(){
10             //使用外圍內的屬性
11             str = "chenssy...";
12             System.out.println(str);
13             //使用外圍內的方法
14             outerDisplay();
15         }
16     }
17     
18     /*推薦使用getxxx()來獲取成員內部類，尤其是該內部類的構造函數無參數時 */
19     public InnerClass getInnerClass(){
20         return new InnerClass();
21     }
22     
23     public static void main(String[] args) {
24         OuterClass outer = new OuterClass();
25         OuterClass.InnerClass inner = outer.getInnerClass();
26         inner.innerDisplay();
27     }
28 }
29 --------------------
30 chenssy...
31 outerClass...

推薦使用getxxx()來獲取成員內部類，尤其是該內部類的構造函數無參數時 。

四、局部內部類

有這樣一種內部類，它是嵌套在方法和作用於內的，對於這個類的使用主要是應用與解決比較復雜的問題，想創建一個類來輔助我們的解決方案，到那時又不希望這個類是公共可用的，所以就產生了局部內部類，局部內部類和成員內部類一樣被編譯，只是它的作用域發生了改變，它只能在該方法和屬性中被使用，出了該方法和屬性就會失效。

對於局部內部類實在是想不出什麽好例子，所以就引用《Think in java》中的經典例子了。

定義在方法裏：

 1 public class Parcel5 {
 2     public Destionation destionation(String str){
 3         class PDestionation implements Destionation{
 4             private String label;
 5             private PDestionation(String whereTo){
 6                 label = whereTo;
 7             }
 8             public String readLabel(){
 9                 return label;
10             }
11         }
12         return new PDestionation(str);
13     }
14     
15     public static void main(String[] args) {
16         Parcel5 parcel5 = new Parcel5();
17         Destionation d = parcel5.destionation("chenssy");
18     }
19 }

定義在作用域內:

 1 public class Parcel6 {
 2     private void internalTracking(boolean b){
 3         if(b){
 4             class TrackingSlip{
 5                 private String id;
 6                 TrackingSlip(String s) {
 7                     id = s;
 8                 }
 9                 String getSlip(){
10                     return id;
11                 }
12             }
13             TrackingSlip ts = new TrackingSlip("chenssy");
14             String string = ts.getSlip();
15         }
16     }
17     
18     public void track(){
19         internalTracking(true);
20     }
21     
22     public static void main(String[] args) {
23         Parcel6 parcel6 = new Parcel6();
24         parcel6.track();
25     }
26 }

五、匿名內部類

在做Swing編程中，我們經常使用這種方式來綁定事件

1 button2.addActionListener(  
2                 new ActionListener(){  
3                     public void actionPerformed(ActionEvent e) {  
4                         System.out.println("你按了按鈕二");  
5                     }  
6                 });

我們咋一看可能覺得非常奇怪，因為這個內部類是沒有名字的，在看如下這個例子：

 1 public class OuterClass {
 2     public InnerClass getInnerClass(final int num,String str2){
 3         return new InnerClass(){
 4             int number = num + 3;
 5             public int getNumber(){
 6                 return number;
 7             }
 8         };        /* 註意：分號不能省 */
 9     }
10     
11     public static void main(String[] args) {
12         OuterClass out = new OuterClass();
13         InnerClass inner = out.getInnerClass(2, "chenssy");
14         System.out.println(inner.getNumber());
15     }
16 }
17 
18 interface InnerClass {
19     int getNumber();
20 }
21 
22 ----------------
23 Output:
24 5

這裏我們就需要看清幾個地方

1、 匿名內部類是沒有訪問修飾符的。

2、 new 匿名內部類，這個類首先是要存在的。如果我們將那個InnerClass接口註釋掉，就會出現編譯出錯。

3、 註意getInnerClass()方法的形參，第一個形參是用final修飾的，而第二個卻沒有。同時我們也發現第二個形參在匿名內部類中沒有使用過，所以當所在方法的形參需要被匿名內部類使用，那麽這個形參就必須為final。

4、 匿名內部類是沒有構造方法的。因為它連名字都沒有何來構造方法。

六、靜態內部類

在java提高篇-----關鍵字static中提到Static可以修飾成員變量、方法、代碼塊，其他它還可以修飾內部類，使用static修飾的內部類我們稱之為靜態內部類，不過我們更喜歡稱之為嵌套內部類。靜態內部類與非靜態內部類之間存在一個最大的區別，我們知道非靜態內部類在編譯完成之後會隱含地保存著一個引用，該引用是指向創建它的外圍內，但是靜態內部類卻沒有。沒有這個引用就意味著：

1、 它的創建是不需要依賴於外圍類的。

2、 它不能使用任何外圍類的非static成員變量和方法。

 1 public class OuterClass {
 2     private String sex;
 3     public static String name = "chenssy";
 4     
 5     /**
 6      *靜態內部類
 7      */
 8     static class InnerClass1{
 9         /* 在靜態內部類中可以存在靜態成員 */
10         public static String _name1 = "chenssy_static";
11         
12         public void display(){
13             /* 
14              * 靜態內部類只能訪問外圍類的靜態成員變量和方法
15              * 不能訪問外圍類的非靜態成員變量和方法
16              */
17             System.out.println("OutClass name :" + name);
18         }
19     }
20     
21     /**
22      * 非靜態內部類
23      */
24     class InnerClass2{
25         /* 非靜態內部類中不能存在靜態成員 */
26         public String _name2 = "chenssy_inner";
27         /* 非靜態內部類中可以調用外圍類的任何成員,不管是靜態的還是非靜態的 */
28         public void display(){
29             System.out.println("OuterClass name：" + name);
30         }
31     }
32     
33     /**
34      * @desc 外圍類方法
35      * @author chenssy
36      * @data 2013-10-25
37      * @return void
38      */
39     public void display(){
40         /* 外圍類訪問靜態內部類：內部類. */
41         System.out.println(InnerClass1._name1);
42         /* 靜態內部類 可以直接創建實例不需要依賴於外圍類 */
43         new InnerClass1().display();
44         
45         /* 非靜態內部的創建需要依賴於外圍類 */
46         OuterClass.InnerClass2 inner2 = new OuterClass().new InnerClass2();
47         /* 方位非靜態內部類的成員需要使用非靜態內部類的實例 */
48         System.out.println(inner2._name2);
49         inner2.display();
50     }
51     
52     public static void main(String[] args) {
53         OuterClass outer = new OuterClass();
54         outer.display();
55     }
56 }
57 ----------------
58 Output:
59 chenssy_static
60 OutClass name :chenssy
61 chenssy_inner
62 OuterClass name：chenssy

上面這個例子充分展現了靜態內部類和非靜態內部類的區別。

轉載自：https://www.cnblogs.com/chenssy/p/3388487.html

Java：詳解內部類