java內部類詳解

⑴ java的內部類有什麼特點 作用和注意

1)根據位置的不同，Java中的內部類分為四種：
 靜態內部類
 使用static修飾，聲明在類體中
 靜態內部類中可以訪問外部類的靜態成員
 成員內部類
 聲明在類體中，不使用static，具有類的成員特徵，也就是，必須有類的實例才能創建內部類實例
 內部類實例可以訪問共享外部類的成員變數（很常用）
 如：鏈表的節點就可以定義為內部類
 局部內部類 把類聲明在方法中，就是局部內部類，作用域
 類似局部變數（很少見）
 匿名內部類
 匿名類，非常常見，可以寫在任何地方,就像一般的語句
 語法更象是創建對象：Date d = new Date(){//...};
 匿名類是對原類的一個繼承，同時創建了實例，{} 就是繼承以後的類體
類體中可使用所有類的語法
 匿名類不能寫構造器
 匿名類可以從抽象類或者介面繼承，必須提供抽象方法的實現
2) 任何內部類都編譯成獨立的class文件
3) 最大的作用：封裝！
 匿名類可以封裝內部概念：情侶間的「土豆」和菜市場的「土豆」是不一樣的

⑵ java中內部類的概念

簡單的說，內部（inner）類指那些類定義代碼被置於其它類定義中的類；而對於一般的、類定義代碼不嵌套在其它類定義中的類，稱為頂層（top-level）類。對於一個內部類，包含其定義代碼的類稱為它的外部（outer）類。 1 Static member class（靜態成員類） 類聲明中包含「static」關鍵字的內部類。如以下示例代碼， Inner1/Inner2/Inner3/Inner4就是Outer的四個靜態成員類。靜態成員類的使用方式與一般頂層類的使用方式基本相同。
1內部類的嵌套可以理解成類的鏈關系，在構造一個內部類(非static)的實例的時候，會將直接外層類的實例
作為參數傳進構造函數，而外層類的實例也是用其外層類的實例構造，所以是一種鏈狀關系，內部的類可以使用所有
外層的類的實例，而外層的類不能使用內層的類， 應用a.this(最外層類實例) ，a.b.c.this(鏈中某個外層的實例)。

class TheOuter{
class kk {
class gg {
int tt = 100;
}
}

class aa {
class bb {
int jj = 10;
class cc {
{ int ff = TheOuter.aa.bb.this.jj;
// 無法直接訪問到gg不在鏈關系內
System.out.println(ff);
}
}
}
}
}

2 創建一個內部類 new aa().new bb().new()cc 實際上是調用 外層類實例.new 本層構造函數()
如果內部類是static的不需要外層類的實例 多個static嵌套的內部類的實例 aa.bb.cc test = new aa.bb.cc();

3
class a0 {
class b0 {
}
}

class vvv{
class ff extends a0.b0 {// ff這里不是內部類也行
ff(a0 kk){
kk.super();
}
}
}
繼承自內部類要調用父類的外層類的super()

4
class dd {
void print(){
System.out.println("dd.println is there");
}
class kk {
kk(int i){}
class cc {
void pp() {
System.out.println("****");
}
void ddpp() {
dd.this.print();
}
}
}
}

class aa {
public static void main (String agrs[]) {
dd.kk.cc test = new dd().new kk(10).new cc();
test.ddpp();
}
}
在類內部可以是使用外層類，但是如果生成一個實例的句柄就沒有提供訪問上層類的功能。

5 this 是指本類的實例

6 預設的new
class cc {
{
new test();
}
class kk {
{
System.out.println("there kk");
}
}

class test {
{
new kk();
}
class kk {
{
System.out.println("there test_kk");
}
}
}
}
可以直接使用new,new的范圍可以是 之際外層.this.new 和this.new 但是如果內層與外層出現同名類以內部優先

7
//當有鏈關系的時候要注意類不要重名
class vv {
class bb {} //!
class kk {
//class vv{} 這樣就會出錯
class bb {} //!這樣就不會出錯
}
}

8
class a0 {
class b0 {
}
}

class vvv{
class ff extends a0.b0 {// 不是內部類也行
ff(a0 kk){
kk.super();
}
}
}
繼承自內部類要調用父類的外層類的super()

9 匿名內部類
interface oo {
//oo(int g) {}
int k = 10;
void pt();
}

class pp {
pp(int g) {
}
int get() {
return 100;
}
}

class me {
/*
interface oo {
void pt();
}
*/
class kk{
oo testmed() {
final int i = 10;
int g = 100;
return new oo() {
int kk;
{
// 使用外面的東西要聲名成final
// 繼承介面內部優先
// 匿名內部類沒有構造函數，只能使用塊，初始化
kk = i + k ;
}
public void pt() {
System.out.println(kk);
}
};
}
pp testmed0() {
return new pp(10){ // 繼承自類
public int get() {
return super.get() * 10;
}
};
}
}
}
匿名內部類可以繼承自介面也可以繼承自類，繼承自類的構造函數中 可以有參數。

10
class bf {
interface kk {}
class aa {
// 介面能嵌套在介面中（不受限制），或者嵌套在頂層，下面就不行
//interface gg {}
}
}

⑶ JAVA中局部內部類和匿名內部類的特點和作用是什麼

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內部類
匿名內部類如果繼承自介面,必須實現指定介面的方法,且無參數
匿名內部類如果繼承自類,參數必須按父類的構造函數的參數傳遞

⑷ java裡面的內部類和外部類是什麼_

外部類：
最普通的，我們平時見到的那種類，就是在一個後綴為.java的文件中，直接定義的類
內部類：
內部類，顧名思義，就是包含在外部類中的類，就叫做內部類。內部類有兩種，一種是靜態內部類，一種是非靜態內部類。
靜態內部類和非靜態內部類之間的區別主要如下：
1、內部原理的區別：
靜態內部類是屬於外部類的類成員，是一種靜態的成員，是屬於類的，就有點類似於private static Singleton instance = null；非靜態內部類，是屬於外部類的實例對象的一個實例成員,靜態類則是屬於所有外部共有的，也就是說，每個非靜態內部類，不是屬於外部類的，是屬於外部類的每一個實例的，創建非靜態內部類的實例以後，非靜態內部類實例，是必須跟一個外部類的實例進行關聯和有寄存關系的。
2、創建方式的區別：
創建靜態內部類的實例的時候，只要直接使用「外部類.內部類()」的方式，就可以，比如School.Teacher()；創建非靜態內部類的實例的時候，必須要先創建一個外部類的實例，然後通過外部類的實例，再來創建內部類的實例，new School().Teacher()
通常來說，我們一般都會為了方便，會選擇使用靜態內部類。

⑸ Java里什麼叫內部類什麼叫外部類

對普通類（沒有內部類的類）來說，內部類和外部類都與他無關；對有內部類的類來說，它們就是其內部類的外部類，外部類是個相對的說法，其實就是有內部類的類。
所以，要回答這個問題，只需要講解內部類是什麼：
Java中的內部類共分為四種：
靜態內部類static inner class (also called nested class)
成員內部類member inner class
局部內部類local inner class
匿名內部類anonymous inner class

靜態內部類Static Inner Class
最簡單的內部類形式。
類定義時加上static關鍵字。
不能和外部類有相同的名字。
被編譯成一個完全獨立的.class文件，名稱為OuterClass$InnerClass.class的形式。
只可以訪問外部類的靜態成員和靜態方法，包括了私有的靜態成員和方法。
生成靜態內部類對象的方式為：
OuterClass.InnerClass inner = new OuterClass.InnerClass();
示例代碼：
package com.learnjava.innerclass;
class StaticInner
{
private static int a = 4;
// 靜態內部類
public static class Inner
{
public void test()
{
// 靜態內部類可以訪問外部類的靜態成員
// 並且它只能訪問靜態的
System.out.println(a);
}
}
}
public class StaticInnerClassTest
{
public static void main(String[] args)
{
StaticInner.Inner inner = new StaticInner.Inner();
inner.test();
}
}

成員內部類Member Inner Class
成員內部類也是定義在另一個類中，但是定義時不用static修飾。
成員內部類和靜態內部類可以類比為非靜態的成員變數和靜態的成員變數。
成員內部類就像一個實例變數。
它可以訪問它的外部類的所有成員變數和方法，不管是靜態的還是非靜態的都可以。
在外部類裡面創建成員內部類的實例：
this.new Innerclass();
在外部類之外創建內部類的實例：
(new Outerclass()).new Innerclass();
在內部類里訪問外部類的成員：
Outerclass.this.member
示例代碼：
package com.learnjava.innerclass;
class MemberInner
{
private int d = 1;
private int a = 2;
// 定義一個成員內部類
public class Inner2
{
private int a = 8;
public void doSomething()
{
// 直接訪問外部類對象
System.out.println(d);
System.out.println(a);// 直接訪問a，則訪問的是內部類里的a
// 如何訪問到外部類里的a呢？
System.out.println(MemberInner.this.a);
}
}
}
public class MemberInnerClassTest
{
public static void main(String[] args)
{
// 創建成員內部類的對象
// 需要先創建外部類的實例
MemberInner.Inner2 inner = new MemberInner().new Inner2();
inner.doSomething();
}
}

局部內部類Local Inner Class
局部內部類定義在方法中，比方法的范圍還小。是內部類中最少用到的一種類型。
像局部變數一樣，不能被public, protected, private和static修飾。
只能訪問方法中定義的final類型的局部變數。
局部內部類在方法中定義，所以只能在方法中使用，即只能在方法當中生成局部內部類的實例並且調用其方法。
示例代碼：
package com.learnjava.innerclass;
class LocalInner
{
int a = 1;
public void doSomething()
{
int b = 2;
final int c = 3;
// 定義一個局部內部類
class Inner3
{
public void test()
{
System.out.println("Hello World");
System.out.println(a);
// 不可以訪問非final的局部變數
// error: Cannot refer to a non-final variable b inside an inner
// class defined in a different method
// System.out.println(b);
// 可以訪問final變數
System.out.println(c);
}
}
// 創建局部內部類的實例並調用方法
new Inner3().test();
}
}
public class LocalInnerClassTest
{
public static void main(String[] args)
{
// 創建外部類對象
LocalInner inner = new LocalInner();
// 調用外部類的方法
inner.doSomething();
}

}

匿名內部類Anonymous Inner Class
匿名內部類就是沒有名字的局部內部類，不使用關鍵字class, extends, implements, 沒有構造方法。
匿名內部類隱式地繼承了一個父類或者實現了一個介面。
匿名內部類使用得比較多，通常是作為一個方法參數。
生成的.class文件中，匿名類會生成OuterClass$1.class文件，數字根據是第幾個匿名類而類推。
示例代碼：
package com.learnjava.innerclass;
import java.util.Date;
public class AnonymouseInnerClass
{
@SuppressWarnings("deprecation")
public String getDate(Date date)
{
return date.toLocaleString();
}
public static void main(String[] args)
{
AnonymouseInnerClass test = new AnonymouseInnerClass();
// 列印日期：
String str = test.getDate(new Date());
System.out.println(str);
System.out.println("----------------");
// 使用匿名內部類
String str2 = test.getDate(new Date()
{
});// 使用了花括弧，但是不填入內容，執行結果和上面的完全一致
// 生成了一個繼承了Date類的子類的對象
System.out.println(str2);
System.out.println("----------------");
// 使用匿名內部類，並且重寫父類中的方法
String str3 = test.getDate(new Date()
{
// 重寫父類中的方法
@Override
@Deprecated
public String toLocaleString()
{
return "Hello: " + super.toLocaleString();
}
});
System.out.println(str3);
}
}

⑹ 什麼是內部類內部類有什麼作用(java)

在Java中，可以將一個類定義在另一個類裡面或者一個方法裡面，這樣的類稱為內部類。廣泛意義上的內部類一般來說包括這四種：成員內部類、局部內部類、匿名內部類和靜態內部類。下面就先來了解一下這四種內部類的用法。

成員內部類是最普通的內部類，它的定義為位於另一個類的內部，形如下面的形式：

class Circle { double radius = 0; public Circle(double radius) { this.radius = radius; } class Draw { //內部類 public void drawSahpe() { System.out.println("drawshape"); } }}

這樣看起來，類Draw像是類Circle的一個成員，Circle稱為外部類。成員內部類可以無條件訪

class Circle { private double radius = 0; public static int count =1; public Circle(double radius) { this.radius = radius; } class Draw { //內部類 public void drawSahpe() { System.out.println(radius); //外部類的private成員 System.out.println(count); //外部類的靜態成員 } }}

不過要注意的是，當成員內部類擁有和外部類同名的成員變數或者方法時，會發生隱藏現象，即默認情況下訪問的是成員內部類的成員。如果要訪問外部類的同名成員，需要以下面的形式進行訪問：

外部類.this.成員變數外部類.this.成員方法

雖然成員內部類可以無條件地訪問外部類的成員，而外部類想訪問成員內部類的成員卻不是這么隨心所欲了。在外部類中如果要訪問成員內部類的成員，必須先創建一個成員內部類的對象，再通過指向這個對象的引用來訪問：

class Circle { private double radius = 0; public Circle(double radius) { this.radius = radius; getDrawInstance().drawSahpe(); //必須先創建成員內部類的對象，再進行訪問 } private Draw getDrawInstance() { return new Draw(); } class Draw { //內部類 public void drawSahpe() { System.out.println(radius); //外部類的private成員 } }}

成員內部類是依附外部類而存在的，也就是說，如果要創建成員內部類的對象，前提是必須存在一個外部類的對象。創建成員內部類對象的一般方式如下：
public class Test { public static void main(String[] args) { //第一種方式： Outter outter = new Outter(); Outter.Inner inner = outter.new Inner(); //必須通過Outter對象來創建 //第二種方式： Outter.Inner inner1 = outter.getInnerInstance(); }} class Outter { private Inner inner = null; public Outter() { } public Inner getInnerInstance() { if(inner == null) inner = new Inner(); return inner; } class Inner { public Inner() { } }}

內部類可以擁有private訪問許可權、protected訪問許可權、public訪問許可權及包訪問許可權。比如上面的例子，如果成員內部類Inner用private修飾，則只能在外部類的內部訪問，如果用public修飾，則任何地方都能訪問；如果用protected修飾，則只能在同一個包下或者繼承外部類的情況下訪問；如果是默認訪問許可權，則只能在同一個包下訪問。這一點和外部類有一點不一樣，外部類只能被public和包訪問兩種許可權修飾。我個人是這么理解的，由於成員內部類看起來像是外部類的一個成員，所以可以像類的成員一樣擁有多種許可權修飾。

⑺ java中內部類

在java語言中，有一種類叫做內部類(inner class)，也稱為嵌入類(nested class)，它是定義在其他類的內部。內部類作為其外部類的一個成員，與其他成員一樣，可以直接訪問其外部類的數據和方法。只不過相比較外部類只有public和默認的修飾符不同，內部類作為一個成員，可以被任意修飾符修飾。編譯器在編譯時，內部類的名稱為OuterClass$InnerClass.class 。

1、內部類訪問數據變數
當在某些時候，內部類中定義的變數與外部類中變數名稱相同時，如何確保正確地訪問每一個變數呢？

1.1在main中直接從外部類調用內部類的方法

class Outer
{
private int index = 10;
class Inner
{
private int index = 20;
void print()
{
int index = 30;
System.out.println(this); // the object created from the Inner
System.out.println(Outer.this); // the object created from the Outer
System.out.println(index); // output is 30
System.out.println(this.index); // output is 20
System.out.println(Outer.this.index); // output is 10
}
}

void print()
{
Inner inner = new Inner();//得到內部類的引用
inner.print();
}
}

class Test
{
public static void main(String[] args)
{
Outer outer = new Outer();
outer.print();
}
}
在這里內部類Inner中關鍵字this指向內部類Inner的對象，如果要想指向外部類的對象，必須在this指針前加上外部類名稱，表示this是指向外部類構造的碎屑，如Outer.this 。

1.2在main中顯式返回內部類引用

class Outer
{
private int index = 10;
class Inner
{
private int index = 20;
void print()
{
int index = 30;
System.out.println(index);
System.out.println(this.index);
System.out.println(Outer.this.index);
}
}

Inner getInner()
{
return new Inner();//返回一個內部類的引用
}
}

class Test
{
public static void main(String[] args)
{
Outer outer = new Outer();
Outer.Inner inner = outer.getInner();
inner.print();
}
}
Inner是Outer的內部類，所以在類Test中必須用屬性引用符來標識出內部類。

1.3當main方法在Outer類內部

class Outer
{
private int index = 10;
class Inner
{
private int index = 20;
void print()
{
int index = 30;
System.out.println(index);
System.out.println(this.index);
System.out.println(Outer.this.index);
}
}

Inner getInner()
{
return new Inner();//返回一個內部類的引用
}

public static void main(String[] args)
{
Outer outer = new Outer();
Inner inner = outer.getInner(); // 注意此處變化
inner.print();
}
}
因為main方法在Outer內部，故可以直接引用，不需要屬性引用符。

1.4在main方法中直接產生內部類對象

class Test
{
public static void main(String[] args)
{
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner(); // 注意此處變化
inner.print();
}
}
在利用new構造方法構造一個外部類對象時，並沒有連帶著構造一個內部類對象，故需要訪問內部類方法時，必須使用new操作符為這個外部類對象再構造一個內部類對象。

2、局部內部類
在方法中定義的內部類是局部內部類，它只能訪問方法中的final類型的局部變數，因為用final定義的局部變數相當於是一個常量，延長了其生命周期，使得方法在消亡時，其內部類仍可以訪問該變數。另外，它同樣也可以引用定義在外部類的變數和方法。而且方法體中的局部內部類不允許有訪問修飾符。

class Outer
{
int num=10;
public void print(final int aArgs)
{
class Inner
{
int num=20;
public Inner()
{
System.out.println("This is Inner.");//此句可看出它與匿名內部類用法的不同。
}

public void print()
{
int num=30;
System.out.println(this); // the object created from the local Inner
System.out.println(num);
System.out.println(this.num);
System.out.println(Outer.this.num);
System.out.println(aArgs);
}
}
Inner inner=new Inner();//此句必須放在定義類Inner的後面
inner.print();
}

public static void main(String[] args)
{
Outer outer=new Outer();
outer.print(40);
}
}
對於局部類的命名，不管是在一個方法中定義多個類還是在幾個方法中分別定義類，其編譯後命名是：OuterClass$1InnerClass.class

3、匿名內部類
匿名內部類作為一種特殊的內部類，除了具有普通內部類的特點，還有自己的一些獨有特性：
匿名內部類必須擴展一個基類或實現一個介面，但是不能有顯式的extends和implements子句；
匿名內部類必須實現父類以及介面中的所有抽象方法；
匿名內部類總是使用父類的無參構造方法來創建實例。如果是實現了一個介面，則其構造方法是Object()；
匿名內部類編譯後的命名為：OuterClass$n.class，其中n是一個從1開始的整數，如果在一個類中定義了多個匿名內部類，則按照他們的出現順序從1開始排號。

abstract class A
{
abstract public void sayHello();
}

class Outer
{
public static void main(String[] args)
{
new Outer().callInner(new A()
{
public void sayHello()
{
System.out.println(this); // the object created from the anonymous Inner
System.out.println("Hello!");
}
});
}

public void callInner(A a)
{
a.sayHello();
}
}

4、靜態內部類
和非靜態內部類相比，區別就在於靜態內部類沒有了指向外部類的引用。除此之外，在任何非靜態內部類中，都不能有靜態數據，靜態方法或者又一個靜態內部類（內部類的嵌套可以不止一層）。不過靜態內部類中卻可以擁有這一切。這也算是兩者的第二個區別吧。一個靜態的內部類,才可以聲明一個static成員，靜態內部類可以訪問外圍類的靜態方法、成員（包括private static的成員）。靜態內部類實例化的時候不必先實例化外圍類，可以直接實例化內部類。而對於非靜態內部類則必須先實例化其外部類，才能再實例化本身。

5．內部類的繼承
當一個類繼承自一個內部類時，預設的構造器不可用。必須使用如下語法：
class WithInner
{
class Inner
{
public void sayHello()
{
System.out.println("Hello.");
}
}
}

public class Test extends WithInner.Inner
{
Test(WithInner wi)
{
wi.super();
}
public static void main(String[] args)
{
WithInner wi=new WithInner();
Test test=new Test(wi);
test.sayHello();
}
}
因為每一個內部類都有一個指向外部類的引用，在繼承一個內部類，必須先創建一個外部類，通過這個外部類引用來調用其內部類的構造方法。如果繼承的內部類是一個靜態內部類，則就不需要這樣，直接super()調用即可；

6、內部類的2種特殊用法
一個類從另一個類派生出來，又要實現一個介面。但在介面中定義的方法與父類中定義的方法的意義不同，則可以利用內部類來解決這個問題。
interface Machine
{
void run();
}

class Person
{
void run()
{
System.out.println("run");
}
}

class Robot extends Person
{
private class MachineHeart implements Machine
{
public void run()
{
System.out.println("heart run");
}
}

Machine getMachine()
{
return new MachineHeart();
}
}

class Test
{
public static void main(String[] args)
{
Robot robot = new Robot();
Machine m = robot.getMachine();
m.run();
robot.run();
}
}
在Robot類內部使用內部類MachineHeart來實現介面Machine的run方法。同時Robot類又繼承了父類Person的run方法。如果不使用內部類MachineHeart而使Robot直接實現介面Machine，則該如何調用父類的run方法？

利用內部類可解決c++中多重繼承所解決的問題
class A
{
void fn1()
{
System.out.println("It' s fn1.");
}
}

abstract class B
{
abstract void fn2();
}

class C extends A
{
B getB()
{
return new B()
{
public void fn2()
{
System.out.println("It' s fn2.");
}
};
}
}

class Test
{
public static void main(String[] args)
{
C c = new C();
c.fn1();
c.getB().fn2();
}
}
類C既要繼承類A又要繼承類B，則可將類B的定義放入類C內部，使之成為內部類。

一般情況下 當我們需要在某一情形下實現一個介面，而在另一情形下又不需要實現這個介面時，我們可以使用內部類來解決這一問題。讓內部類來實現這個介面。另外一個很好的理由是java內部類加上介面可以有效地實現多重繼承。