Java內部類那些事

內部類這種東西因為平時工作時很少用到，加上本人記憶力不好，所以現在造成了一種這樣的狀況，很多細節東西用的時候翻書找著了，看一下明白了，接著用上。不到一星期之后馬上又忘了。最近做東西用到一個復雜的數據結構又需要使用內部類來解決，寫到這個地方的時候很多細節又想不起來了，無奈之下把一天沒動的屁股挪開去翻書~對于我這樣的懶人來說這是件很痛苦的事，我決定這次我要把內部類的知識好好總結一下,不保證從這以后永遠不忘，但是起碼到時候我不用再麻煩的去找書，讀一下這篇小文章就行了。

一、關于Java內部類

Java中的內部類是外部類的一部分，是外部類一個完整的正式的成員，內部類的實例可以訪問外部類的所有成員，包括哪些標識為private的成員!(權利很大!)

二、常規內部類:
1.編寫常規內部類:
所謂的常規內部類是那些以這種形式來定義的類:
public class Outer{

  class Inner{

  }

}
其中Inner就是一個常規的內部類，有常規的就又不常規的，不常規的像是靜態的(使用static關鍵字修飾的)、局部方法的、匿名的,不急，稍后介紹

如果我們將上面的Outer類進行編譯：
java Outer.java
那么就會得到兩個類文件，其中一個叫Outer.class，另一個名字比較怪，叫Outer$Inner.class 這是內部類的Java字節碼文件

雖然我們看到內部類最終會像外部類那樣生成一個獨立的class文件，但是它還是有限制的:內部類中不可以包含任何類型的static聲明!切記這一點!如果要訪問內部類我們只能通過一個外部類的活實例!
2.實例化內部類:
要實例化一個內部類分為兩種情況:1.在外部類實例化內部類 2.在外部類之外實例化內部類

第一種情況:
這個很簡單，沒什么可討論的，像平時完全一樣:

class Outer{

  class Inner{
    public Inner(){
       System.out.println("Inner Alive!");   
    }
  }

  public void createInner(){
    Inner inner=new Inner();
  }
}

OK!這個沒有什么好說的!
第二種情況有點兒學問:

前面我們說過，如果要在外部類之外訪問內部類，那么就需要通過一個外部類的實例,這樣就會使代碼看起來似乎有些怪:

public static void main(String[] args){
    Outer outer=new Outer();      //創建一個外部類的對象
    Outer.Inner inner=outer.new Inner();  //創建內部類的實例inner,很怪?馬上解釋!這也是我最最記不住的一點兒
}

首先看引用inner的類型是Outer.Inner說明這是一個Outer內部類Inner的一個實例，當然，同往常一樣，你這樣寫也是沒問題的:Object inner,只是在類型轉換的還是要使用Outer.Inner,如:

Object o=outer.new Inner();

if(o instanceof Outer.Inner){
   o=(Outer.Inner)o;
}

然而最怪的還是它:outer.new Inner();  我們是通過外部類對象outer來像調用其它方法一樣來調用Inner類的構造函數。如果要直接生成一個內部類實例，可以這樣去寫代碼:

Outer.Inner inner=new Outer().new Inner();

大多數情況下第二種情況用的不是很多，稍微知道有這么回事就可以了，以后如果真的用到了，那么再回來讀這篇文章吧

3.this到底指的是誰?
這個問題我們就會經常碰到了!如果我們在內部類中使用this,這個this指的是誰?

首先我們回憶一下this關鍵字的規則:
(1)關鍵字this只能在實例代碼內部使用，實力代碼就是除了靜態代碼(包括靜態方法和靜態初始化塊)之外的地方。
(2)this引用是對當前正在執行的對象的引用

根據第二條，內部類中的this會引用該內部類的實例，這是我們所需要的，符合我們的習慣。但是有很多時候你需要去在內部類中引用外部類的當前實例，這種情況我們該怎么辦?Java當然為這種情況也提供了解決方案,可以這樣寫:Outer.this

public class Outer {
 private int x;
 
 public Outer(int xIn){
  x=xIn;
 }

 class Inner{
  private int x;
  
  public Inner(int xIn){
   x=xIn;
  }
  
  public void showX(){
   System.out.println("The x of inner:"+this.x);
   System.out.println("The x of outer:"+Outer.this.x);
  }
  
 }
 
 
}

public class Test {

 public static void main(String[] args) {
  Outer out=new Outer(10);
  Outer.Inner in=out.new Inner(7);
  in.showX();
 }

}
程序輸出結果:
The x of inner:7
The x of outer:10

三、方法內部類:
常規的就這些值得注意的問題，下面介紹一些"非主流"的類:
當年學習JavaScript的時候看到在函數里面可以定義函數感到非常驚奇!然而在Java中我們可以在方法中定義類!作為一名Java程序員，我們有必要了解它這個奇特的性質,這是一個方法內部類的例子:

public class Outer {
 private int x=7;

 public void doNothing(){
                //Note here!這就是傳說中的在方法中聲明的類!
  class Inner{
   private int x=100;
   public void showX(){
    System.out.println("The x of inner:"+this.x);
    System.out.println("The x of outer:"+Outer.this.x);
   }
  }
  Inner in=new Inner();
  in.showX();
 }
}
public class Test {

 public static void main(String[] args){
  Outer out=new Outer();
  out.doNothing();
 }
}

程序執行的結果:
The x of inner:100
The x of outer:7
使用方法內部類所需要注意的問題:
1.只能夠在方法內部中聲明這個類的實例，而且聲明實例的地方必須位于內部類定義的后面!否則編譯器不會發現這個內部類!就會產生編譯錯誤!
2.方法內部類可以訪問外部類的所有成員，最值得注意的是:內部類對象雖然是在方法內部，但是它堅決不可以訪問它所在方法的局部變量!除非該變量類型為final
3.靜態方法中也可以聲明這種方法內部類!但是該內部類只能訪問外部類的靜態成員!
4.方法內部類也會產生類文件!文件名同常規內部類!

對于第二條原則，我在這里再做一下詳細的解釋:
因為所有的方法局部變量都位于棧上，隨著方法調用完畢，這些局部變量也會隨之丟失!而類，包括所有的內部類，其信息是位于堆上的!因此我們無法保證內部類的生存周期同方法局部變量的生存周期相同，因此便有了這條規定！而對于final值確是永不變的!因此我們可以在內部類中使用方法的final變量!

四、匿名內部類
談到匿名內部類，我不由得想起了匿名數組,其實兩者是基本上相似的,這里順便也說一下匿名數組
匿名數組是Java中構建數組的快捷方式,其基本形式如下所示:
int[] array=new int[]{1,2,3,4,5,6,7,8,9};
這樣我們就可以隨時方便的構造數組，最常用的地方就是把它用作帶數組參數的方法變元:
setArray(new int[]{1,2,3,4,5,6});
值得注意的有一點:構建匿名數組時我們不需要為它指定大小,例如這種寫法new int[3]{1,2,3};就會造成編譯錯誤!

好了，知道了匿名數組，我們來看匿名內部類,假設有一個抽象類:
abstract class Animal(){
  public abstract void run();
}

Animal是一個抽象類，它擁有一個抽象的方法run(),假設我們要為它“制造”一個子類的對象dog,按照常規的方法，我們需要寫一個Dog類來繼承Animal類，然后重寫具體的run()方法，但是匿名內部類卻為我們提供了另一種解決方案:

public Animal createDog(){
  Animal dog=new Animal(){
     public void run(){
        System.out.println("The dog runs very fast!");
     }
  };               //不要漏掉分號!
  return dog;
}

這樣就返回了一個對象dog,它具體的實現了方法run(),但是這樣做有一個局限性，如果我們要為該對象實現一種Animal沒有的行為play(),雖然能夠在匿名內部類中定義該方法，但是我們永遠無法去調用它!因為返回的類型永遠是Animal,而Dog類型是不存在的!因此，這種情況下我們還是要采用第一種解決方案!

另外，不僅僅是抽象類，非final的類(因為這樣做相當于繼承，而final是不允許繼承的)還有接口都可以生成相應的匿名內部類!

五、靜態內部類:
其實就是標識為static的內部類:
public class Outer {
 int x=10;
 static int s=100;
 
 static class SInner{
  public void doNoting(){
   System.out.println(s);   //只能訪問靜態字段s,如果訪問x就會出現編譯錯誤!
  }
 }
}

public class Test {

 public static void main(String[] args){
  Outer.SInner inner=new Outer.SInner(); //創建static內部類的實例，跟創建普通外部類的方法幾乎一樣，對嗎?
  inner.doNoting();
 }
}

OK!Java內部類的情況基本上就這么多吧!嗯！現在記得很扎實！寫幾個小例子練練~然后開始別的工作!~~哈哈