Java內部類

一、常規內部類

       所謂常規內部類，或者說內部類，指的就是除去後面三種之外的內部類（這算什麼解釋。。。）先寫一個最簡單的內部類的例子：

/* * 常規內部類demo。 */ package com.wang.java.Demo; public class Outer{ private int x = 1; public Outer(){ System.out.println("Outer sign"); } class Inner{ public Inner(){ System.out.println("Inner Sign!"); } private int x =2; public void add(){ int x = 3; System.out.println(x); System.out.println(this.x); System.out.println(Outer.this.x); } } public static void main(String[] args) { Inner inner = new Outer().new Inner(); inner.add(); } }

編譯後的運行結果：outer sign  

                  Inner Sign

                  3

                  2

                  1

在上面的例子裏可以清晰的看到：

1  內部類就像一個實例成員一樣存在於外部類中。

2  內部類可以訪問外部類的所有成員就想訪問自己的成員一樣沒有限制。

3  內部類中的this 指的是內部類的實例對象本身，如果要用外部類的實例對象就可以用類名 .this 的方式   獲得。

4  內部類對象中不能有靜態成員，原因很簡單，內部類的實例對象是外部類實例對象的一個成員。

內部類的創建方法：

1  在外部類的內部，可以用 Inner inner = new Inner();  方法直接創建

2  在外部類外部，必須先創建外部類實例，然後再創建內部類實例，除了上面 Inner inner = new Outer().new Inner() 的寫法以外，還有  Outer outer = new Outer(); Inner inner = outer.new Inner(); 的寫法

二、 局部內部類：

    把類定義在方法體內，  這個類稱之爲局部內部類。

/* * 局部內部類Demo */ package com.wang.java.Demo; public class Outer01 { private int x = 1; public void doSomeThing() { final int y = 2; class Inner { int x = 3; void print() { int x = 4; System.out.print(x); System.out.print(this.x); System.out.println(Outer01.this.x); System.out.print(y); } } Inner inner = new Inner(); inner.print(); } public static void main(String[] args) { Outer01 o = new Outer01(); o.doSomeThing(); } }

運行結果：4 、 3 、 1 、 2

1  局部內部類的地位和方法內的局部變量的位置類似，因此不能修飾局部變量的修飾符也不能修飾局部內部類，譬如public 、 private 、 protected 、 static 、 transient 等

2  局部內部類只能在聲明的方法內是可見的，因此定義局部內部類之後，想用的話就要在方法內直接實例化，記住這裏順序不能反了，一定是要先聲明後使用，否則編譯器會說找不到。

3  局部內部類不能訪問定義它的方法內的局部變量，除非這個變量被定義爲final  。

三、匿名內部類：

             把內部類的定義和聲明寫到一起時，就不用給這個類起個類名而是直接使用了，這種形式的內部類根本就沒有類名，因此我們叫它匿名內部類。

/* * 匿名內部類demo */ package com.wang.java.Demo; public class Wife { public interface Dear{ public void byfriendlly(); public void angry(); } public static void main(String[] args) { Dear wife = new Dear(){ @Override public void byfriendlly() { System.out.println("親親 ^_^"); } @Override public void angry() { System.out.println("別給我說話，離我遠點！"); } }; wife.byfriendlly(); System.out.println("++++++++++++++++++++"); wife.angry(); } }

1  第一匿名內部類可以是個接口，這個沒什麼好奇怪的哈。

2  第12 行到第 21 行是一個語句，就是定義了一個對象，因此 21 行大括號後面有個分號。

3  匿名內部類用 new  Dear (){ … } 的方式把聲明類的過程和創建類的實例的過程合二爲一。

4  匿名內部類可以是某個類的繼承子類也可以是某個接口的實現類。

方法參數內的匿名內部類 ：

/* * 方法參數內的局部內部類Demo */ package com.wang.java.Demo; public class Dog { static abstract class Ball{ abstract String getName(); } void play(Ball ball){ System.out.println(ball.getName()); } public static void main(String[] args) { Dog dog = new Dog(); dog.play(new Ball(){ @Override String getName() { return "pi qiu"; } }); }

四、 靜態嵌套類

當一個內部類前面用static 修飾時，我們稱之爲靜態嵌套類或者說靜態內部類。

package com.wang.java.Demo; public class Outer02 { static int x = 1; static class Inner{ void print(){ System.out.println("Inner++"+x); } } public static void main(String[] args) { Outer02.Inner inner = new Outer02.Inner(); inner.print(); } }

因爲靜態嵌套類和其他靜態方法一樣只能訪問其它靜態的成員，而不能訪問實例成員。因此靜態嵌套類和外部類（封裝類）之間的聯繫就很少了，他們之間可能也就 是命名空間上的一些關聯。上面例子中你需要注意的就是靜態嵌套類的聲明方法 new Outer.Nest()  連續寫了兩個類名，以至於我們都懷疑前面的 Outer 是個包名了，好在包名一般都小寫的，要不還真分不清 ……