java內部類分析詳解
可以將一個類的定義放在另一個類的定義內部，這就是內部類。
內部類是一個非常有用的特性但又比較難理解使用的特性（鄙人到現在都沒有怎么使用過內部類，對內部類也只是略知一二）。
第一次見面
內部類我們從外面看是非常容易理解的，無非就是在一個類的內部在定義一個類。
publicclassOuterClass { privateString name ; privateintage; publicString getName（） {returnname; } publicvoidsetName（String name） { this.name = name; } publicintgetAge（） {returnage; } publicvoidsetAge（ intage） { this.age = age; } class InnerClass{publicInnerClass（）{ name = “chenssy”; age = 23; } } }
在這里InnerClass就是內部類，對于初學者來說內部類實在是使用的不多，鄙人菜鳥一個同樣沒有怎么使用過（貌似僅僅只在做swing 注冊事件中使用過），但是隨著編程能力的提高，我們會領悟到它的魅力所在，它可以使用能夠更加優雅的設計我們的程序結構。在使用內部類之間我們需要明白為什么要使用內部類，內部類能夠為我們帶來什么樣的好處。
一、為什么要使用內部類
為什么要使用內部類？在《Think in java》中有這樣一句話：使用內部類最吸引人的原因是：每個內部類都能獨立地繼承一個（接口的）實現，所以無論外圍類是否已經繼承了某個（接口的）實現，對于內部類都沒有影響。
在我們程序設計中有時候會存在一些使用接口很難解決的問題，這個時候我們可以利用內部類提供的、可以繼承多個具體的或者抽象的類的能力來解決這些程序設計問題?？梢赃@樣說，接口只是解決了部分問題，而內部類使得多重繼承的解決方案變得更加完整。
publicinterfaceFather{} publicinterfaceMother{} publicclassSonimplementsFather， Mother{}publicclassDaughterimplementsFather{classMother_implementsMother{} }
其實對于這個實例我們確實是看不出來使用內部類存在何種優點，但是如果Father、Mother不是接口，而是抽象類或者具體類呢？這個時候我們就只能使用內部類才能實現多重繼承了。
其實使用內部類最大的優點就在于它能夠非常好的解決多重繼承的問題，但是如果我們不需要解決多重繼承問題，那么我們自然可以使用其他的編碼方式，但是使用內部類還能夠為我們帶來如下特性（摘自《Think in java》）：
1、內部類可以用多個實例，每個實例都有自己的狀態信息，并且與其他外圍對象的信息相互獨立。 2、在單個外圍類中，可以讓多個內部類以不同的方式實現同一個接口，或者繼承同一個類。 3、創建內部類對象的時刻并不依賴于外圍類對象的創建。 4、內部類并沒有令人迷惑的“is-a”關系，他就是一個獨立的實體。 5、內部類提供了更好的封裝，除了該外圍類，其他類都不能訪問。 二、內部類基礎
在這個部分主要介紹內部類如何使用外部類的屬性和方法，以及使用.this與.new。
當我們在創建一個內部類的時候，它無形中就與外圍類有了一種聯系，依賴于這種聯系，它可以無限制地訪問外圍類的元素。
publicclassOuterClass{privateString name ; privateintage; /**省略getter和setter方法**/publicclassInnerClass{publicInnerClass（）{ name = “chenssy”; age = 23; }publicvoiddisplay（）{ System.out.println（ “name：”+ getName（） + “ ;age：”+ getAge（））; } }publicstaticvoidmain（String［］ args） { OuterClass outerClass = newOuterClass（）; OuterClass.InnerClass innerClass = outerClass. newInnerClass（）; innerClass.display（）; } } -------------- Output： name：chenssy ;age： 23
在這個應用程序中，我們可以看到內部了InnerClass可以對外圍類OuterClass的屬性進行無縫的訪問，盡管它是private修飾的。這是因為當我們在創建某個外圍類的內部類對象時，此時內部類對象必定會捕獲一個指向那個外圍類對象的引用，只要我們在訪問外圍類的成員時，就會用這個引用來選擇外圍類的成員。
其實在這個應用程序中我們還看到了如何來引用內部類：引用內部類我們需要指明這個對象的類型：OuterClasName.InnerClassName。同時如果我們需要創建某個內部類對象，必須要利用外部類的對象通過.new來創建內部類： OuterClass.InnerClass innerClass = outerClass.new InnerClass（）;。
同時如果我們需要生成對外部類對象的引用，可以使用OuterClassName.this，這樣就能夠產生一個正確引用外部類的引用了。當然這點實在編譯期就知曉了，沒有任何運行時的成本。
/** * Java學習交流QQ群：589809992 我們一起學Java！ */publicclassOuterClass{publicvoiddisplay（）{ System.out.println（ “OuterClass.。?！保? }publicclassInnerClass{publicOuterClass getOuterClass（）{ returnOuterClass. this; } }publicstaticvoidmain（String［］ args） { OuterClass outerClass = newOuterClass（）; OuterClass.InnerClass innerClass = outerClass. newInnerClass（）; innerClass.getOuterClass（）.display（）; } } ------------- Output： OuterClass.。。
到這里了我們需要明確一點，內部類是個編譯時的概念，一旦編譯成功后，它就與外圍類屬于兩個完全不同的類（當然他們之間還是有聯系的）。對于一個名為OuterClass的外圍類和一個名為InnerClass的內部類，在編譯成功后，會出現這樣兩個class文件：OuterClass.class和OuterClass$InnerClass.class。
在Java中內部類主要分為成員內部類、局部內部類、匿名內部類、靜態內部類。
三、成員內部類
成員內部類也是最普通的內部類，它是外圍類的一個成員，所以他是可以無限制的訪問外圍類的所有 成員屬性和方法，盡管是private的，但是外圍類要訪問內部類的成員屬性和方法則需要通過內部類實例來訪問。
在成員內部類中要注意兩點，第一：成員內部類中不能存在任何static的變量和方法；第二：成員內部類是依附于外圍類的，所以只有先創建了外圍類才能夠創建內部類。
publicclassOuterClass { privateString str; publicvoidouterDisplay（）{ System. out.println（“outerClass.。。”）; } publicclassInnerClass{ publicvoidinnerDisplay（）{ //使用外圍內的屬性str =“chenssy.。。”; System. out.println（str）; //使用外圍內的方法outerDisplay（）; } } /*推薦使用getxxx（）來獲取成員內部類，尤其是該內部類的構造函數無參數時 */publicInnerClassgetInnerClass（）{ returnnewInnerClass（）; } publicstaticvoidmain（String［］ args） { OuterClass outer = newOuterClass（）; OuterClass.InnerClass inner = outer.getInnerClass（）; inner.innerDisplay（）; } } -------------------- chenssy.。。 outerClass.。。
推薦使用getxxx（）來獲取成員內部類，尤其是該內部類的構造函數無參數時 。
四、局部內部類
有這樣一種內部類，它是嵌套在方法和作用于內的，對于這個類的使用主要是應用與解決比較復雜的問題，想創建一個類來輔助我們的解決方案，到那時又不希望這個類是公共可用的，所以就產生了局部內部類，局部內部類和成員內部類一樣被編譯，只是它的作用域發生了改變，它只能在該方法和屬性中被使用，出了該方法和屬性就會失效。
對于局部內部類實在是想不出什么好例子，所以就引用《Think in java》中的經典例子了。
定義在方法里：
/** * Java學習交流QQ群：589809992 我們一起學Java！ */publicclassParcel5{publicDestionation destionation（String str）{ class PDestionation implements Destionation{ privateString label; privatePDestionation（String whereTo）{ label = whereTo; } publicString readLabel（）{ returnlabel; } } returnnewPDestionation（str）; }publicstaticvoidmain（String［］ args） { Parcel5 parcel5 = newParcel5（）; Destionation d = parcel5.destionation（ “chenssy”）; } }
定義在作用域內：
publicclassParcel6 { privatevoidinternalTracking（boolean b）{ if（b）{ class TrackingSlip{privateString id; TrackingSlip（String s） { id = s; } String getSlip（）{ returnid; } } TrackingSlip ts = newTrackingSlip（ “chenssy”）; String string= ts.getSlip（）; } } publicvoidtrack（）{ internalTracking（ true）; } publicstaticvoidmain（String［］ args） { Parcel6 parcel6 =newParcel6（）; parcel6.track（）; } }五、匿名內部類
在做Swing編程中，我們經常使用這種方式來綁定事件
button2.addActionListener（ newActionListener（）{ publicvoidactionPerformed（ActionEvent e） { System. out.println（ “你按了按鈕二”）; } }）;
我們咋一看可能覺得非常奇怪，因為這個內部類是沒有名字的，在看如下這個例子：
/** * Java學習交流QQ群：589809992 我們一起學Java！ */publicclassOuterClass{publicInnerClass getInnerClass（ finalintnum，String str2）{returnnewInnerClass（）{ intnumber = num + 3; publicintgetNumber（）{ returnnumber; } }; /* 注意：分號不能省 */} publicstaticvoidmain（String［］ args） { OuterClass out =newOuterClass（）; InnerClass inner = out.getInnerClass（ 2， “chenssy”）; System.out.println（inner.getNumber（））; } } interface InnerClass { intgetNumber（）; } ---------------- Output：
這里我們就需要看清幾個地方
1、 匿名內部類是沒有訪問修飾符的。
2、 new 匿名內部類，這個類首先是要存在的。如果我們將那個InnerClass接口注釋掉，就會出現編譯出錯。
3、 注意getInnerClass（）方法的形參，第一個形參是用final修飾的，而第二個卻沒有。同時我們也發現第二個形參在匿名內部類中沒有使用過，所以當所在方法的形參需要被匿名內部類使用，那么這個形參就必須為final。
4、 匿名內部類是沒有構造方法的。因為它連名字都沒有何來構造方法。
PS：由于篇幅有限，對匿名內部類就介紹到這里，有關更多關于匿名內部類的知識，我就會在下篇博客（java提高篇—–詳解匿名內部類）做詳細的介紹，包括為何形參要定義成final，怎么對匿名內部類進行初始化等等，敬請期待……
六、靜態內部類
在java提高篇——關鍵字static中提到Static可以修飾成員變量、方法、代碼塊，其他它還可以修飾內部類，使用static修飾的內部類我們稱之為靜態內部類，不過我們更喜歡稱之為嵌套內部類。靜態內部類與非靜態內部類之間存在一個最大的區別，我們知道非靜態內部類在編譯完成之后會隱含地保存著一個引用，該引用是指向創建它的外圍內，但是靜態內部類卻沒有。沒有這個引用就意味著：
1、 它的創建是不需要依賴于外圍類的。
2、 它不能使用任何外圍類的非static成員變量和方法。
/** * Java學習交流QQ群：589809992 我們一起學Java！ */publicclassOuterClass{privateString sex; publicstaticString name = “chenssy”; /** *靜態內部類 */staticclass InnerClass1{ /* 在靜態內部類中可以存在靜態成員 */publicstaticString _name1 = “chenssy_static”; publicvoiddisplay（）{ /* * 靜態內部類只能訪問外圍類的靜態成員變量和方法 * 不能訪問外圍類的非靜態成員變量和方法 */System.out.println（ “OutClass name ：”+ name）; } } /** * 非靜態內部類 */class InnerClass2{ /* 非靜態內部類中不能存在靜態成員 */publicString _name2 = “chenssy_inner”; /* 非靜態內部類中可以調用外圍類的任何成員，不管是靜態的還是非靜態的 */publicvoiddisplay（）{ System.out.println（ “OuterClass name：”+ name）; } } /** *@desc外圍類方法 *@authorchenssy *@data2013-10-25 *@returnvoid */publicvoiddisplay（）{ /* 外圍類訪問靜態內部類：內部類。 */System.out.println（InnerClass1._name1）; /* 靜態內部類 可以直接創建實例不需要依賴于外圍類 */newInnerClass1（）.display（）; /* 非靜態內部的創建需要依賴于外圍類 */OuterClass.InnerClass2 inner2 = newOuterClass（）。 newInnerClass2（）; /* 方位非靜態內部類的成員需要使用非靜態內部類的實例 */System.out.println（inner2._name2）; inner2.display（）; } publicstaticvoidmain（String［］ args） { OuterClass outer =newOuterClass（）; outer.display（）; } } ---------------- Output： chenssy_static OutClass name ：chenssy chenssy_inner OuterClass name：chenssy
上面這個例子充分展現了靜態內部類和非靜態內部類的區別。
非常好我支持^.^
(0) 0%
不好我反對
(0) 0%