Java內部類的使用小結(轉)


內部類是指在一個外部類的內部再定義一個類。類名不需要和文件夾相同。
*內部類可以是靜態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.     } 
2. 局部內部類
      局部內部類,是指內部類定義在方法和作用域內。Thinking in Java給了這么兩個例子:
定義在方法內:
  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.     } 
 定義在作用域里:
  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.     } 
      局部內部類也像別的類一樣進行編譯,但只是作用域不同而已,只在該方法或條件的作用域內才能使用,退出這些作用域后無法引用的。
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. //注釋后,編譯時提示類Inner找不到 
  19. /* interface Inner { 
  20.     String getName(); 
  21. } */ 
同時在這個例子,留意外部類的方法的形參, 當所在的方法的形參需要被內部類里面使用時,該形參必須為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. abstract class Inner { 
  19.     Inner(String name, String city) { 
  20.         System.out.println(city); 
  21.     } 
  22.  
  23.     abstract String getName(); 
注意這里的形參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. interface Inner { 
  34.     String getName(); 
  35.     String getProvince(); 
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 = new InheritInner(wi); 
  11.     } 
  12.  
  13. class WithInner { 
  14.     class Inner { 
  15.  
  16.     } 
可以看到子類的構造函數里面要使用 父類的外部類對象.super();而這個對象需要從外面創建並傳給形參。
 
至於內部類的重載,感覺Thinking in Java的例子很復雜,在平常應用中應該很少,因為有點難懂,不清晰。而內部類和閉包之間的事情,暫時放下,以后再看。
 
【解惑】領略Java內部類的“內部”
內部類有兩種情況:
(1) 在類中定義一個類(私有內部類,靜態內部類)
(2) 在方法中定義一個類(局部內部類,匿名內部類)
 
1、私有內部類 —— 在方法之間定義的內部類,非靜態
      我們首先看看類中內部類的兩個特點:
      (1) 在外部類的作用范圍內可以任意創建內部類對象,即使內部類是私有的(私有內部類)。即內部類對包圍它的外部類可見。
例如 (實際上,內部類是可以設置為public公開的,但一般我是當做成員變量設置為private)
  1. //代碼1:內部類對外部類可見 
  2. class Outer{ 
  3.     //創建私有內部類對象 
  4.     public Inner in=new Inner(); 
  5.  
  6.     //私有內部類 
  7.     private class Inner{ 
  8.          ... 
  9.     } 
 
      (2) 在內部類中可以訪問其外部類的所有域,即使是私有域。即外部類對內部類可見。
例如
  1. //代碼2:外部類對內部類可見 
  2. //(內部類可以訪問外部類的所有成員變量和方法) 
  3. class Outer{ 
  4.     //外部類私有數據域 
  5.     private int data=0; 
  6.  
  7.     //內部類 
  8.     class Inner{ 
  9.         void print(){ 
  10.             //內部類訪問外部私有數據域 
  11.             System.out.println(data); 
  12.         } 
  13.     } 
 
      問題來了:上面兩個特點到底如何辦到的呢?內部類的"內部"到底發生了什么?
       其實,內部類是Java編譯器一手操辦的。虛擬機並不知道內部類與常規類有什么不同。 編譯器是如何瞞住虛擬機的呢?
       對內部類進行編譯后發現有兩個class文件:Outer.class 和Outer$Inner.class 。這說明內部類Inner仍然被編譯成一個獨立的類(Outer$Inner.class),而不是Outer類的某一個域。 虛擬機運行的時候,也是把Inner作為一種常規類來處理的。
 
      但問題來了,即然是兩個常規類,為什么他們之間可以互相訪問私有域那(最開始提到的兩個內部類特點)?這就要問問編譯器到底把這兩個類編譯成什么東西了。
 
        我們利用reflect反射機制來探查了一下內部類編譯后的情況(關於探查類內部機制的代碼提供在下面的附件里Reflect.java)。
        (1)、編譯代碼1生成 Outer$Inner.class 文件后使用 ReflectUtil.reflect("Outer$Inner") 對內部類Inner進行反射。運行結果 發現了三個隱含的成分:
  1. //反編譯代碼
  2. class Outer$Inner
  3. {
  4.     Outer$Inner(Outer,Outer$Inner);  //包可見構造器
  5.     private Outer$Inner(Outer);   //私有構造器將設置this$0域
  6.     final Outer this$0;   //外部類實例域this$0
  7. }
    好了,現在我們可以解釋上面的第一個內部類特點了: 為什么外部類可以創建內部類的對象?並且內部類能夠方便的引用到外部類對象?
     首先編譯器將外、內部類編譯后放在同一個包中。在內 部類中附加一個包可見構造器。這樣, 虛擬機運行Outer類中Inner in=new Inner(); 實際上調用的是包可見構造: new Outer$Inner(this,null)。因此即使是private內部類,也會通過隱含的包可見構造器成功的獲得私有內部類的構造權限。
      再者,Outer$Inner類中有一個指向外部類Outer的引用this$0,那么通過這個引用就可以方便的得到外部類對象中可見成員。但是Outer類中的private成員是如何訪問到的呢?這就要看看下面Outer.class文件中的秘密了。
 
    (2)、編譯代碼2生成 Outer.class文件,然后使用 ReflectUtil.reflect("Outer") 對外部類Outer進行反射 。 運行結果 發現一個隱含成分如下:
  1. //反編譯代碼 
  2. class Outer 
  3.     static int access$0(Outer);  //靜態方法,返回值是外部類私有域 data 的值 
    現在可以解釋第二個特點了: 為什么內部類可以引用外部類的私有域?
    原因的關鍵就在編譯器在外圍類中添加了靜態方法access$0。 它將返回值作為參數傳遞給他的對象域data。這樣內部類Inner中的打印語句:
                 System.out.println(data);
     實際上運行的時候調用的是:
                 System.out.println(this$0.access$0(Outer));
 
總結一下編譯器對類中內部類做的手腳吧:
(1)  在內部類中偷偷摸摸的創建了包可見構造器,從而使外部類獲得了創建權限。
(2)  在外部類中偷偷摸摸的創建了訪問私有變量的靜態方法,從而 使 內部類獲得了訪問權限。
這樣,類中定義的內部類無論私有,公有,靜態都可以被包圍它的外部類所訪問。
 
2、靜態內部類  ——  在方法間定義的內部類,靜態
    內部類也有靜態的區別,這就是靜態內部類,我們來看看代碼:
  1. package hr.test; 
  2. //代碼3:靜態內部類對外部變量的引用 
  3. public class Outer{ 
  4.     private static int i=0; 
  5.  
  6.     //創建靜態內部類對象 
  7.     public Inner in=new Inner(); 
  8.  
  9.     //靜態內部類 
  10.     private static class Inner{ 
  11.         public void print(){ 
  12.             System.out.println(i);   //如果i不是靜態變量,這里將無法通過編譯 
  13.         } 
  14.     }  
    靜態內部類和私有內部類最大的區別在於,靜態內部類中無法引用到其外圍類的非靜態成員。這是為什么?我們還是來看看靜態內部類Outer$Inner中發生了什么吧?
  1. //反編譯代碼 
  2. class Outer$Inner 
  3.     private Outer$Inner(); 
  4.     Outer$Inner(hr.test.Outer$Inner); 
    與上面私有內部類反編譯1比較發現, 少了一個指向外圍類對象的引用final Outer this$0; 也就是說靜態內部類無法得到其外圍類對象的引用,那么自然也就無法訪問外圍類的非靜態成員了。因此,靜態內部類只能訪問其外圍類的靜態成員,除此之外與非靜態內部類沒有任何區別。
 
3、局部內部類 —— 在方法中定義的內部類
      方法內部類也有兩個特點
      (1)   方法中的內部類沒有訪問修飾符, 即方法內部類對包圍它的方法之外的任何東西都不可見。
      (2)   方法內部類只能夠訪問該方法中的局部變量,所以也叫局部內部類。而且這些局部變量一定要是final修飾的常量。
例如
  1. class Outter{ 
  2.     public void outMethod(){ 
  3.         final int beep=0; 
  4.         class Inner{ 
  5.             //使用beep 
  6.         } 
  7.  
  8.         Inner in=new Inner(); 
  9.     } 
      這又是為什么呢?
      (1) 我們首先對Outter類進行反射發現,Outter中再也沒有返回私有域的隱藏方法了。
      (2) 對Inner類的反射發現,Inner類內部多了一個對beep變量的備份隱藏域:final int val$i;
 
      我們可以這樣解釋Inner類中的這個備份常量域,首先當JVM運行到需要創建Inner對象之后,Outter類已經全部運行完畢,這是垃圾回收機制很有可能釋放掉局部變量beep。那么Inner類到哪去找beep變量呢?
       編譯器又出來幫我們解決了這個問題,他在Inner類中創建了一個beep的備份 ,也就是說即使Ouuter中的beep被回收了,Inner中還有一個備份存在,自然就不怕找不到了。
      但是問題又來了。如果Outter中的beep不停的在變化那。那豈不是也要讓備份的beep變量無時無刻的變化。 為了保持局部變量與局部內部類中備份域保持一致。 編譯器不得不規定死這些局部域必須是常量,一旦賦值不能再發生變化了。
      所以為什么局部內部類應用外部方法的域必須是常量域的原因所在了。
 
 
內部類的特點總結
 
(1)  在方法間定義的非靜態內部類: 
       ● 外圍類和內部類可互相訪問自己的私有成員。
       ● 內部類中不能定義靜態成員變量。

(2) 在方法間定義的靜態內部類:
       ● 只能訪問外部類的靜態成員。
 
(3) 在方法中定義的局部內部類:
       ● 該內部類沒有任何的訪問控制權限
       ● 外圍類看不見方法中的局部內部類的,但是局部內部類可以訪問外圍類的任何成員。
       ● 方法體中可以訪問局部內部類,但是訪問語句必須在定義局部內部類之后。
       ● 局部內部類只能訪問方法體中的常量,即用final修飾的成員。

(4) 在方法中定義的匿名內部類:
       ● 沒有構造器,取而代之的是將構造器參數傳遞給超類構造器。


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM