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 outer_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的。
解釋一下,爲什麼必須是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內部類
匿名內部類如果繼承自接口,必須實現指定接口的方法,且無參數 
匿名內部類如果繼承自類,參數必須按父類的構造函數的參數傳遞
發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章