概念及特性：

內部類

       類與類之間除了繼承關係之外，還存在巢狀關係，即一個類可以宣告包含另一個類，被包含的類稱為內部類（inner class），包含內部類的類稱為外部類，此時內部類成為外部類的成員。

Java不支援C++語言的結構（struct）型別，當實際應用中需要使用及結構時，可以宣告一個類；當結構作為陣列的元素型別，或一個類中需要使用結構時，可將結構宣告為內部類。

       1 宣告內部類：

       一個類可以宣告包含一個內部類。例如，一條直線可以由起點和終點表示，一個點是由兩個座標值組成的一個“結構”，因此可以將點類Point設計成直線類Line的內部類。

直線類宣告如下：

       public class Line{                                    //直線類，外部類

       protected Point start,end;                 //直線的起點和終點

       protected class Point{                       //點類，內部類

              protected int x,y;                       //內部類的成員變數

              protected Point(int x,int y){              //內部類的構造方法

       this.x = x;

       this.y = y;

}

}

}

其中，直線類有兩個成員變數start、end，分別表示直線的起點和終點，資料型別是點型別Point；點類有兩個成員變數x、y，分別表示一個點的座標。

2 內部類特性：

       在外部類中宣告內部類之後，從類與類之間的關係來看，外部類包含內部類，外部類與內部類之間構成類的巢狀結構；從類與成員之間的關係來看，內部類是外部類的成員。因此，內部類即有類的特性，也有類成員的特性。

       內部類的特性說明：

（1）       內部類的類特性：

·內部類不能與外部類同名！

·內部類具有封裝性。內部類中可以宣告成員變數與成員方法，用過建立內部類的物件，引用其成員變數和呼叫其成員方法。

·內部類成員可以與外部類成員同名。

·內部類具有繼承性，可宣告內部類繼承父類或實現介面。

·內部類具有抽象性。可以宣告內部類為抽象類，但該抽象類必須被其他內部類繼承，可宣告內部類為介面，但該內部介面必須被其他內部類實現。

（2）       內部類的成員性：

·內部類可以使用運算子“.”進行引用。例如，引用直線類Line中的內部類Point格式如下：Line.Point；

·使用許可權修飾符private，protected，public宣告內部類具體有四種類中的成員訪問許可權。

·內部類具有靜態特性。可使用static宣告內部類為靜態內部類。

闡述即總結：

1，概述
內部類是指在一個外部類的內部再定義一個類。
內部類作為外部類的一個成員，並且依附於外部類而存在的。
內部類可為靜態，可用PROTECTED和PRIVATE修飾。（而外部類不可以：外部類只能

使用PUBLIC和DEFAULT）。

2，分類
成員內部類、
區域性內部類、
靜態內部類、
匿名內部類（圖形是要用到，必須掌握）。

3，使用方法

A，成員內部類：
作為外部類的一個成員存在，與外部類的屬性、方法並列。

public class Outer {
private static int i = 1;
private int j = 10;
private int k = 20;
public static void outer_f1(){

}
public void outer_f2(){

}

// 成員內部類中，不能定義靜態成員
// 成員內部類中，可以訪問外部類的所有成員
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.變數名
System.out.println(Outer.this.j);//在內部類中

訪問外部類中與內部類同名的例項變數用 外部類名.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兩類。

注意：當Outer是一個private類時，外部類對於其外部訪問是私有的，所以就無法

建立外部類物件，進而也無法建立內部類物件。

B，區域性內部類
在方法中定義的內部類稱為區域性內部類。
與區域性變數類似，在區域性內部類前不加修飾符public和private，其範圍為定義它的

程式碼塊。

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);
}

}

注意：
在類外不可直接生成區域性內部類（保證區域性內部類對外是不可見的）。
要想使用區域性內部類時需要生成物件，物件呼叫方法，在方法中才能呼叫其區域性內部

類。
通過內部類和介面達到一個強制的弱耦合，用區域性內部類來實現介面，並在方法中返

回介面型別，使區域性內部類不可見，遮蔽實現類的可見性。

C，靜態內部類：（注意：前三種內部類與變數類似，所以可以對照參考變數）
靜態內部類定義在類中，任何方法外，用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來進行定義。例子：
對於兩個類，擁有相同的方法：
People
{
run();
}
Machine{
run();
}
此時有一個robot類：
class Robot extends People implement Machine.
此時run()不可直接實現。
注意：當類與介面（或者是介面與介面）發生方法命名衝突的時候，此時必須使用內

部類來實現。
用介面不能完全地實現多繼承，用介面配合內部類才能實現真正的多繼承。

D，匿名內部類
匿名內部類是一種特殊的區域性內部類，它是通過匿名類實現介面。
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。
如果一個物件編譯時的型別是介面，那麼其執行的型別為實現這個介面的類。
因匿名內部類無構造方法，所以其使用範圍非常的有限。
當需要多個物件時使用區域性內部類，因此區域性內部類的應用相對比較多。匿名內部類

中不能定義構造方法。如果一個物件編譯時的型別是介面，那麼其執行的型別為實現

這個介面的類。
因匿名內部類無構造方法，所以其使用範圍非常的有限。