內部類是指在一個外部類的內部再定義一個類。類名不需要和資料夾相同。 *內部類可以是靜態static的，也可用public，default，protected和private修飾。（而外部頂級類即類名和檔名相同的只能使用public和default）。   注意：內部類是一個編譯時的概念，一旦編譯成功，就會成為完全不同的兩類。對於一個名為outer的外部類和其內部定義的名為inner的內部類。編譯完成後出現outer.class和outer$inner.class兩類。 所以內部類的成員變數/方法名可以和外部類的相同。

1. 成員內部類

      成員內部類，就是作為外部類的成員，可以直接使用外部類的所有成員和方法，即使是private的。同時外部類要訪問內部類的所有成員變數/方法，則需要通過內部類的物件來獲取。       要注意的是，成員內部類不能含有static的變數和方法。 因為成員內部類需要先建立了外部類，才能建立它自己的，瞭解這一點，就可以明白更多事情，在此省略更多的細節了。       在成員內部類要引用外部類物件時，使用outer.this來表示外部類物件；       而需要建立內部類物件，可以使用outer.inner  obj = outerobj.new inner();

1. public class Outer { 
2.     public static void main(String[] args) { 
3.         Outer outer = new Outer(); 
4.         Outer.Inner inner = outer.new
    Inner(); 
5.         inner.print("Outer.new"); 
6.  
7.         inner = outer.getInner(); 
8.         inner.print("Outer.get"); 
9.     } 
10.  
11.     // 個人推薦使用getxxx()來獲取成員內部類，尤其是該內部類的建構函式無引數時 
12.     public Inner getInner() { 
13.         return new Inner(); 
14.     } 
15.  
16.     public class Inner { 
17.         public void print(String str) { 
18.             System.out.println(str); 
19.         } 
20.     } 
21. } 

2. 區域性內部類

      區域性內部類，是指內部類定義在方法和作用域內。給了這麼兩個例子： 定義在方法內：

1. public class Parcel4 { 
2.     public Destination destination(String s) { 
3.         class PDestination implements Destination { 
4.             private String label; 
5.  
6.             private PDestination(String whereTo) { 
7.                 label = whereTo; 
8.             } 
9.  
10.             public String readLabel() { 
11.                 return label; 
12.             } 
13.         } 
14.         return new PDestination(s); 
15.     } 
16.  
17.     public static void main(String[] args) { 
18.         Parcel4 p = new Parcel4(); 
19.         Destination d = p.destination("Tasmania"); 
20.     } 
21. } 

 定義在作用域裡：

1. public class Parcel5 { 
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("slip"); 
14.             String s = ts.getSlip(); 
15.         } 
16.     } 
17.  
18.     public void track() { 
19.         internalTracking(true); 
20.     } 
21.  
22.     public static void main(String[] args) { 
23.         Parcel5 p = new Parcel5(); 
24.         p.track(); 
25.     } 
26. } 

      區域性內部類也像別的類一樣進行編譯，但只是作用域不同而已，只在該方法或條件的作用域內才能使用，退出這些作用域後無法引用的。

3. 巢狀內部類

       巢狀內部類，就是修飾為static的內部類。宣告為static的內部類，不需要內部類物件和外部類物件之間的聯絡，就是說我們可以直接引用outer.inner，即不需要建立外部類，也不需要建立內部類。        巢狀類和普通的內部類還有一個區別：普通內部類不能有static資料和static屬性，也不能包含巢狀類，但巢狀類可以。而巢狀類不能宣告為private，一般宣告為public，方便呼叫。

4. 匿名內部類

      有時候我為了免去給內部類命名，便傾向於使用匿名內部類，因為它沒有名字。例如：

1. ((Button) findViewById(R.id.start)).setOnClickListener(new Button.OnClickListener() { 
2.     @Override 
3.     public void onClick(View v) { 
4.         new Thread() { 
5.  
6.             @Override 
7.             public void run() { 
8.                 // TODO Auto-generated method stub 
9.             } 
10.  
11.         }.start(); 
12.     } 
13. }); 

      匿名內部類是不能加訪問修飾符的。 要注意的是，new 匿名類，這個類是要先定義的，看下面例子：

1. public class Outer { 
2.     public static void main(String[] args) { 
3.         Outer outer = new Outer(); 
4.         Inner inner = outer.getInner("Inner", "gz"); 
5.         System.out.println(inner.getName()); 
6.     } 
7.  
8.     public Inner getInner(final String name, String city) { 
9.         return new Inner() { 
10.             private String nameStr = name; 
11.  
12.             public String getName() { 
13.                 return nameStr; 
14.             } 
15.         }; 
16.     } 
17. } 
18.  
19. //註釋後，編譯時提示類Inner找不到 
20. /* interface Inner { 
21.     String getName(); 
22. } */ 

同時在這個例子，留意外部類的方法的形參， 當所在的方法的形參需要被內部類裡面使用時，該形參必須為final。這裡可以看到形參name已經定義為final了，而形參city 沒有被使用則不用定義為final。為什麼要定義為final呢？在網上找到本人比較如同的解釋：  “這是一個編譯器設計的問題，如果你瞭解java的編譯原理的話很容易理解。   首先，內部類被編譯的時候會生成一個單獨的內部類的.class檔案，這個檔案並不與外部類在同一class檔案中。   當外部類傳的引數被內部類呼叫時，從java程式的角度來看是直接的呼叫例如：   public void dosome(final String a,final int b){     class Dosome{public void dosome(){System.out.println(a+b)}};     Dosome some=new Dosome();     some.dosome();   }   從程式碼來看好像是那個內部類直接呼叫的a引數和b引數，但是實際上不是，在java編譯器編譯以後實際的操作程式碼是   class Outer$Dosome{     public Dosome(final String a,final int b){     this.Dosome$a=a;     this.Dosome$b=b;   }     public void dosome(){     System.out.println(this.Dosome$a+this.Dosome$b);   }   }}   從以上程式碼看來，內部類並不是直接呼叫方法傳進來的引數，而是內部類將傳進來的引數通過自己的構造器備份到了自己的內部，自己內部的方法呼叫的實際是自己的屬性而不是外部類方法的引數。   這樣理解就很容易得出為什麼要用final了，因為兩者從外表看起來是同一個東西，實際上卻不是這樣，如果內部類改掉了這些引數的值也不可能影響到原引數，然而這樣卻失去了引數的一致性，因為從程式設計人員的角度來看他們是同一個東西，如果程式設計人員在程式設計的時候在內部類中改掉引數的值，但是外部呼叫的時候又發現值其實沒有被改掉，這就讓人非常的難以理解和接受，為了避免這種尷尬的問題存在，所以編譯器設計人員把內部類能夠使用的引數設定為必須是final來規避這種莫名其妙錯誤的存在。”  (簡單理解就是，拷貝引用，為了避免引用值發生改變，例如被外部類的方法修改等，而導致內部類得到的值不一致，於是用final來讓該引用不可改變)         因為匿名內部類，沒名字，是用預設的建構函式的，無引數的，那如果需要引數呢？則需要該類有帶引數的建構函式：

1. public class Outer { 
2.     public static void main(String[] args) { 
3.         Outer outer = new Outer(); 
4.         Inner inner = outer.getInner("Inner", "gz"); 
5.         System.out.println(inner.getName()); 
6.     } 
7.  
8.     public Inner getInner(final String name, String city) { 
9.         return new Inner(name, city) { 
10.             private String nameStr = name; 
11.  
12.             public String getName() { 
13.                 return nameStr; 
14.             } 
15.         }; 
16.     } 
17. } 
18.  
19. abstract class Inner { 
20.     Inner(String name, String city) { 
21.         System.out.println(city); 
22.     } 
23.  
24.     abstract String getName(); 
25. } 

注意這裡的形參city，由於它沒有被匿名內部類直接使用，而是被抽象類Inner的建構函式所使用，所以不必定義為final。         而匿名內部類通過例項初始化，可以達到類似構造器的效果：

1. public class Outer { 
2.     public static void main(String[] args) { 
3.         Outer outer = new Outer(); 
4.         Inner inner = outer.getInner("Inner", "gz"); 
5.         System.out.println(inner.getName()); 
6.         System.out.println(inner.getProvince()); 
7.     } 
8.  
9.     public Inner getInner(final String name, final String city) { 
10.         return new Inner() { 
11.             private String nameStr = name; 
12.             private String province; 
13.  
14.             // 例項初始化 
15.             { 
16.                 if (city.equals("gz")) { 
17.                     province = "gd"; 
18.                 }else { 
19.                     province = ""; 
20.                 } 
21.             } 
22.  
23.             public String getName() { 
24.                 return nameStr; 
25.             } 
26.  
27.             public String getProvince() { 
28.                 return province; 
29.             } 
30.         }; 
31.     } 
32. } 
33.  
34. interface Inner { 
35.     String getName(); 
36.     String getProvince(); 
37. } 

5.內部類的繼承

      內部類的繼承，是指內部類被繼承，普通類 extents 內部類。而這時候程式碼上要有點特別處理，具體看以下例子：

1. public class InheritInner extends WithInner.Inner { 
2.  
3.     // InheritInner() 是不能通過編譯的，一定要加上形參 
4.     InheritInner(WithInner wi) { 
5.         wi.super(); 
6.     } 
7.  
8.     public static void main(String[] args) { 
9.         WithInner wi = new WithInner(); 
10.         InheritInner obj = 

    相關推薦

    java內部類小結

    內部類 作用特點 隱藏程式碼 可以訪問外圍類 訪問外圍類 和組合是完全不同的概念 內部類和屬性一樣有訪問許可權的修飾 內部類訪問外圍類不受訪問許可權的影響 例項化類時,內部類不會被例項化;c++ sizeof()不會計算內部類大小 匿名內部類 c和c++

    Java內部類的使用小結

    提示 key 內部 效果 com where out alt 文件 轉自：http://android.blog.51cto.com/268543/384844/ 內部類是指在一個外部類的內部再定義一個類。類名不需要和文件夾相同。 *內部類可以是靜態static的，也可

    Java內部類的使用小結 形參為什麽要用final

    trac som 調用 匿名內部類 事情 ani 如果 method 方法 部類是指在一個外部類的內部再定義一個類。類名不需要和文件夾相同。 *內部類可以是靜態static的，也可用public，default，protected和private修飾。（而外部頂級類即類名和

    Java內部類北京PK10平臺出租的使用小結

    依賴 修飾 ava face 賦值 類的靜態成員 結束 new 引用 為什麽要北京PK10平臺出租（www.1159880099.com）QQ1159880099 使用內部類：使用內部類最吸引人的原因是：每個內部類都能獨立地繼承一個（接口的）實現，所以無論外圍類是否已經繼承

    Java 內部類的小結

    內部類是指在一個外部類的內部再定義一個類。類名不需要和資料夾相同。 *內部類可以是靜態static的，也可用public，default，protected和private修飾。（而外部頂級類即類名和檔名相同的只能使用public和default）。 &nbs

    Java內部類(成員內部類、靜態內部類、區域性內部類、匿名內部類)小結

    內部類不是很好理解，但說白了其實也就是一個類中還包含著另外一個類 如同一個人是由大腦、肢體、器官等身體結果組成，而內部類相當於其中的某個器官之一，例如心臟：它也有自己的屬性和行為（血液、跳動） 顯然，此處不能單方面用屬性或者方法表示一個心臟，而需要一個類

    Java內部類使用小結

    內部類是指在一個外部類的內部再定義一個類。類名不需要和資料夾相同。 *內部類可以是靜態static的，也可用public，default，protected和private修飾。（而外部頂級類即類名和檔名相同的只能使用public和default）。 注意：內部類是

    Java內部類的使用小結 形參為什麼要用final

    部類是指在一個外部類的內部再定義一個類。類名不需要和資料夾相同。 *內部類可以是靜態static的，也可用public，default，protected和private修飾。（而外部頂級類即類名和檔名相同的只能使用public和default）。 注意：內部類是

    Java內部類引用外部類中的局部變量為何必須是final問題解析

    lib soft 編譯器 art http word tail ace 軟件 今天編寫一個多線程程序，發現在方法內定義內部類時，如果內部類調用了方法中的變量，那麽該變量必須申明為final類型，百思不得其解，後來想到應該是生命周期的原因，因為方法內定義的變量是局部變量，

    Java內部類之匿名內部類

    urn nat 看到了 math 通過 rri 內部 test mat ??我們都知道Java中可以使用內部類，將一個類的定義放在另一個類的定義的內部，這就是內部類，但是匿名內部類往往使我們摸不著頭腦，因為它並沒有特定的名稱，那麽該如何使用它呢？ 定義一個匿名內部類 pu

    Java內部類基本使用

    add size sel 整體 object 方法 句柄 protected 基本使用 鏈接到外部類 ??創建內部類時，那個類的對象同時擁有封裝對象(封裝內部類的外部類)的一個鏈接，所以內部類可以訪問外部類的成員。??內部類擁有對外部類所有元素的訪問權限。??看如下代碼，內

    JAVA 內部類 （二）

    匿名內部類 獨立 button strong 知識 desc ets .get xxx 一、為什麽要使用內部類 為什麽要使用內部類？在《Think in java》中有這樣一句話：使用內部類最吸引人的原因是：每個內部類都能獨立地繼承一個（接口的）實現，所以無論外

    Java內部類持有外部類的引用詳細分析與解決方案

    調用 lai urn star keyword inner android get sta 在Java中內部類的定義與使用一般為成員內部類與匿名內部類，他們的對象都會隱式持有外部類對象的引用，影響外部類對象的回收。 GC只會回收沒有被引用或者根集不可到達的對象（取決於GC算

    java 內部類

    所在 on() 定義變量 實現接口 特性 for sed prot ring 內部類(innerclasses) 一般情況，我們把類定義成獨立的單元。有些情況下，我們把一個類放在另一個類的內部定義，稱為內部類。 內部類的作用： 1. 內部類提供了更

    Java內部類

    局部內部類 參數 修飾 變量 default 參數傳遞 ted ati private 部類是指在一個外部類的內部再定義一個類。類名不需要和文件夾相同。 *內部類可以是靜態static的，也可用public，default，protected和private修飾。（而外部頂

    java 內部類和閉包

    ice end trac 定義 stat 常見 tostring change wan 內部類（inner class） public class Outer{ private String name; class Inner{ publi

    java 內部類 嵌套類

    seq hub 存在 邏輯 val blog ems 不能 pri 概述 java允許我們把一個類a定義在另一個類b裏面,那麽這個類a就叫做內部類。例如如下面： 如果內部類似Non-static的那麽被稱作內部類 class OuterClass { ... class

    java內部類作用

    修改 private end 之一 class 需要 sta bean sid 推薦一、 定義 放在一個類的內部的類我們就叫內部類。 二、 作用 1.內部類可以很好的實現隱藏 一般的非內部類，是不允許有 private 與protected權限的，但內部類可以

    Java內部類(5)：應用例

    ont 應用 情況 test 調用 sub() spa ren tro 例1-閉包(Closure) 閉包是一個可調用的對象(通過Callback)，它記錄了一些信息，這些信息來自於創建它的作用域 1 interface Incrementable { 2 v

    java內部類之成員內部類

    cte 對象 todo 定義 包括 類屬性 out pri int 內部類概念：顧名思義，就是將一個類定義在另一個個類內部。內部的類稱之為內部類 。 內部類的主要特點：1.內部類可以很好的實現隱藏，可以使用protected、private修飾符。2.內部類可以直接訪問外部