Java 內部類 
分四種：成員內部類、區域性內部類、靜態內部類和匿名內部類。 
1、成員內部類： 即作為外部類的一個成員存在，與外部類的屬性、方法並列。
注意：成員內部類中不能定義靜態變數,但可以訪問外部類的所有成員。
public class Outer{
private static int i = 1;
private int j=10;
private int k=20;
public static void outer_f1(){
    //do more something
}
public void out_f2(){
    //do more something
}

//成員內部類
class Inner{
//static int inner_i =100; //內部類中不允許定義靜態變數
int j=100;//內部類中外部類的
 
例項變數可以共存
int inner_i=1;
void inner_f1(){
    System.out.println(i);//外部類的變數如果和內部類的變數沒有同名的，則可以直接用變數名訪問外部類的變數
    System.out.println(j);//在內部類中訪問內部類自己的變數直接用變數名
    System.out.println(this.j);//也可以在內部類中用"this.變數名"來訪問內部類變數
    //訪問外部類中與內部類同名的例項變數可用"外部類名.this.變數名"。
    System.out.println(k);//外部類的變數如果和內部類的變數沒有同名的，則可以直接用變數名訪問外部類的變數
    outer_f1();
    outer_f2();
}
}
//外部類的非靜態方法訪問成員內部類
public void outer_f3(){
    Inner inner = new Inner();
    inner.inner_f1();
}

//外部類的靜態方法訪問成員內部類，與在外部類外部訪問成員內部類一樣
public static void outer_f4(){
    //step1 建立外部類物件
    Outer out = new Outer();
    //***step2 根據外部類物件建立內部類物件***
    Inner inner=out.new Inner();
    //step3 訪問內部類的方法
    inner.inner_f1();
}

public static void main(String[] args){
    outer_f4();
}
}
成員內部類的優點：
⑴ 內部類作為外部類的成員，可以訪問外部類的私有成員或屬性。（即使將外部類宣告為PRIVATE，但是對於處於其內部的內部類還是可見的。）
⑵ 用內部類定義在外部類中不可訪問的屬性。這樣就在外部類中實現了比外部類的private還要小的
 
訪問許可權。
注意：內部類是一個編譯時的概念，一旦編譯成功，就會成為完全不同的兩類。對於一個名為outer的外部類和其內部定義的名為inner的內部類。編譯完成後出現outer.class和outer$inner.class兩類。
2、區域性內部類： 即在方法中定義的內部類，與區域性變數類似，在區域性內部類前不加修飾符public或private，其範圍為定義它的程式碼塊。
注意：區域性內部類中不可定義靜態變數，可以訪問外部類的區域性變數(即方法內的變數)，但是變數必須是final的。
public class Outer {
 private int s = 100;
 private int out_i = 1;
 public void f(final int k){
  final int s = 200;
  int i = 1;
  final int j = 10;
  class Inner{ //定義在方法內部
   int s = 300;//可以定義與外部類同名的變數
   //static int m = 20;//不可以定義靜態變數
   Inner(int k){
    inner_f(k);
   }
   int inner_i = 100;
   void inner_f(int k){
    System.out.println(out_i);//如果內部類沒有與外部類同名的變數，在內部類中可以直接訪問外部類的
 
例項變數
    System.out.println(k);//*****可以訪問外部類的區域性變數(即方法內的變數)，但是變數必須是final的*****
//    System.out.println(i);
    System.out.println(s);//如果內部類中有與外部類同名的變數，直接用變數名訪問的是內部類的變數
    System.out.println(this.s);//用"this.變數名" 訪問的也是內部類變數
    System.out.println(Outer.this.s);//用外部"外部類類名.this.變數名" 訪問的是外部類變數
   }
  }
  new Inner(k);
 }

 public static void main(String[] args) {
 //訪問區域性內部類必須先有外部類物件
  Outer out = new Outer();
  out.f(3);
 }

}

注意：
在類外不可直接生成區域性內部類（保證區域性內部類對外是不可見的）。要想使用區域性內部類時需要生成物件，物件呼叫方法，在方法中才能呼叫其區域性內部類。通過內部類和介面達到一個強制的弱耦合，用區域性內部類來實現介面，並在方法中返回介面型別，使區域性內部類不可見，遮蔽實現類的可見性。

3、靜態內部類： 靜態內部類定義在類中，任何方法外，用static定義。
注意：靜態內部類中可以定義靜態或者非靜態的成員
public class Outer {
 private static int i = 1;
 private int j = 10;
 public static void outer_f1(){
 
 }
 public void outer_f2(){
 
 }
// 靜態內部類可以用public,protected,private修飾
// 靜態內部類中可以定義靜態或者非靜態的成員
 static class Inner{
  static int inner_i = 100;
  int inner_j = 200;
  static void inner_f1(){
   System.out.println("Outer.i"+i);//靜態內部類只能訪問外部類的靜態成員
   outer_f1();//包括靜態變數和靜態方法
  }
  void inner_f2(){
//   System.out.println("Outer.i"+j);//靜態內部類不能訪問外部類的非靜態成員
//   outer_f2();//包括非靜態變數和非靜態方法
  } 
 
 }
 
 public void outer_f3(){
//  外部類訪問內部類的靜態成員：內部類.靜態成員
  System.out.println(Inner.inner_i);
  Inner.inner_f1();
//  外部類訪問內部類的非靜態成員:例項化內部類即可
  Inner inner = new Inner();
  inner.inner_f2();
 
 }
 public static void main(String[] args) {
  new Outer().outer_f3();
 }

}

注意：*******生成（new）一個靜態內部類不需要外部類成員：這是靜態內部類和成員內部類的區別。靜態內部類的物件可以直接生成：
Outer.Inner in=new Outer.Inner()；
而不需要通過生成外部類物件來生成。這樣實際上使靜態內部類成為了一個頂級類。靜態內部類不可用private來進行定義。*******

例子：
對於兩個類，擁有相同的方法：
class People
{
  run();
}
class Machine{
   run();
}
此時有一個robot類：
class Robot extends People implement Machine.
此時run()不可直接實現。
注意：當類與介面（或者是介面與介面）發生方法命名衝突的時候，此時必須使用內部類來實現。用介面不能完全地實現多繼承，用介面配合內部類才能實現真正的多繼承。

4、匿名內部類 
匿名內部類是一種特殊的區域性內部類，它是通過匿名類實現介面。
IA被定義為介面。
IA I=new IA(){};

匿名內部類的特點：

1，一個類用於繼承其他類或是實現介面，並不需要增加額外的方法，只是對繼承方法的事先或是覆蓋。
2，只是為了獲得一個物件例項，不需要知道其實際型別。
3，類名沒有意義，也就是不需要使用到。

public class Outer {
 private static int i = 1;
 private int j = 10;
 public static void outer_f1(){
 
 }
 public void outer_f2(){
 
 }
// 靜態內部類可以用public,protected,private修飾
// 靜態內部類中可以定義靜態或者非靜態的成員
 static class Inner{
  static int inner_i = 100;
  int inner_j = 200;
  static void inner_f1(){
   System.out.println("Outer.i"+i);//靜態內部類只能訪問外部類的靜態成員
   outer_f1();//包括靜態變數和靜態方法
  }
  void inner_f2(){
//   System.out.println("Outer.i"+j);//靜態內部類不能訪問外部類的非靜態成員
//   outer_f2();//包括非靜態變數和非靜態方法
  }
 }
 
 public void outer_f3(){
//  外部類訪問內部類的靜態成員：內部類.靜態成員
  System.out.println(Inner.inner_i);
  Inner.inner_f1();
//  外部類訪問內部類的非靜態成員:例項化內部類即可
  Inner inner = new Inner();
  inner.inner_f2();
 
 }
 public static void main(String[] args) {
  new Outer().outer_f3();
 }

}

注：一個匿名內部類一定是在new的後面，用其隱含實現一個介面或實現一個類，沒有類名，根據多型，我們使用其父類名。因他是區域性內部類，那麼區域性內部類的所有限制都對其生效。匿名內部類是唯一一種無構造方法類。大部分匿名內部類是用於介面回撥用的。匿名內部類在編譯的時候由系統自動起名Out$1.class。如果一個物件編譯時的型別是介面，那麼其執行的型別為實現這個介面的類。因匿名內部類無構造方法，所以其使用範圍非常的有限。當需要多個物件時使用區域性內部類，因此區域性內部類的應用相對比較多。匿名內部類中不能定義構造方法。如果一個物件編譯時的型別是介面，那麼其執行的型別為實現這個介面的類。

________________________________________________________________________________

內部類總結：
1.首先，把內部類作為外部類的一個特殊的成員來看待，因此它有類成員的封閉等級：private ,protected,預設(friendly),public
                                                      它有類成員的修飾符:   static,final,abstract
2.非靜態內部類nested inner class,內部類隱含有一個外部類的指標this,因此，它可以訪問外部類的一切資源（當然包括private）
  外部類訪問內部類的成員，先要取得內部類的物件,並且取決於內部類成員的封裝等級。
  非靜態內部類不能包含任何static成員.
3.靜態內部類：static inner class,不再包含外部類的this指標，並且在外部類裝載時初始化.
  靜態內部類能包含static或非static成員.
  靜態內部類只能訪問外部類static成員.
  外部類訪問靜態內部類的成員，循一般類法規。對於static成員，用類名.成員即可訪問，對於非static成員，只能
    用物件.成員進行訪問

4.對於方法中的內部類或塊中內部類只能訪問塊中或方法中的final變數。

類成員有兩種static , non-static，同樣內部類也有這兩種
non-static 內部類的例項，必須在外部類的方法中建立或通過外部類的例項來建立(OuterClassInstanceName.new innerClassName(ConstructorParameter)),並且可直接訪問外部類的資訊,外部類物件可通過OuterClassName.this來引用
static 內部類的例項, 直接建立即可，沒有對外部類例項的引用。
內部類不管static還是non-static都有對外部類的引用
non-static 內部類不允許有static成員

方法中的內部類只允許訪問方法中的final區域性變數和方法的final引數列表，所以說方法中的內部類和內部類沒什麼區別。但方法中的內部類不能在方法以外訪問，方法中不可以有static內部類
匿名內部類如果繼承自介面,必須實現指定介面的方法,且無引數 
匿名內部類如果繼承自類,引數必須按父類的建構函式的引數傳遞