成員內部類

class Demo1_InnerClass {
	public static void main(String[] args) {
		//Inner i = new Inner();
		//i.method();
		//外部類名.內部類名 = 外部類物件.內部類物件
		Outer.Inner oi = new Outer().new Inner();			//建立內部類物件
		oi.method();

	}
}

/*
* A:內部類概述
* B:內部類訪問特點
	* a:內部類可以直接訪問外部類的成員，包括私有。
	* b:外部類要訪問內部類的成員，必須建立物件。
	* 外部類名.內部類名 物件名 = 外部類物件.內部類物件;
* 
*/

class Outer {
	private int num = 10;
	class Inner {
		public void method() {
			System.out.println(num);
		}
	}
}
 

class Demo2_InnerClass {
	public static void main(String[] args) {
		//Outer.Inner oi = new Outer().new Inner();
		//oi.method();

		Outer o = new Outer();
		o.print();
	}
}

class Outer {
	private int num = 10;
	private class Inner {
		public void method() {
			System.out.println(num);
		}
	}

	public void print() {
		Inner i = new Inner();
		i.method();
	}
}
 

class Test1_InnerClass {
	public static void main(String[] args) {
		Outer.Inner oi = new Outer().new Inner();
		oi.show();
	}
}
//要求：使用已知的變數，在控制檯輸出30，20，10。
//內部類之所以能獲取到外部類的成員,是因為他能獲取到外部類的引用外部類名.this
class Outer {
	public int num = 10;
	class Inner {
		public int num = 20;
		public void show() {
			int num = 30;
			System.out.println(num);
			System.out.println(this.num);
			System.out.println(Outer.this.num);
		}
	}
}
 

靜態內部類

class Demo1_InnerClass {
	public static void main(String[] args) {
		//外部類名.內部類名 物件名 = 外部類名.內部類物件;
		Outer.Inner oi = new Outer.Inner();
		oi.method();

		Outer.Inner2.print();
	}
}

class Outer {
	static class Inner {
		public void method() {
			System.out.println("method");
		}
	}

	static class Inner2 {
		public static void print() {
			System.out.println("print");
		}
	}
}

區域性內部類

class Demo1_InnerClass {
	public static void main(String[] args) {
		Outer o = new Outer();
		o.method();
	}
}
//區域性內部類
class Outer {
	public void method() {
		final int num = 10;
		class Inner {
			public void print() {
				System.out.println(num);
			}
		}

		Inner i = new Inner();
		i.print();
	}

	/*public void run() {
		Inner i = new Inner();				//區域性內部類,只能在其所在的方法中訪問
		i.print();
	}*/
}

匿名內部類

class Demo1_NoNameInnerClass {
	public static void main(String[] args) {
		Outer o = new Outer();
		o.method();
	}
}
/*
* A:匿名內部類
	* 就是內部類的簡化寫法。
* B:前提：存在一個類或者介面
	* 這裡的類可以是具體類也可以是抽象類。
* C:格式：
* 
		new 類名或者介面名(){
			重寫方法;
		}
* D:本質是什麼呢?
	* 是一個繼承了該類或者實現了該介面的子類匿名物件。
*
*/

interface Inter {
	public void print();
}

class Outer {
	class Inner implements Inter {
		public void print() {
			System.out.println("print");
		}
	}

	public void method(){
		//Inner i = new Inner();
		//i.print();
		//new Inner().print();
		//Inter i = new Inner();			//父類引用指向子類物件
		
		new Inter() {						//實現Inter介面
			public void print() {			//重寫抽象方法
				System.out.println("print");
			}
		}.print();
	}
}

class Demo2_NoNameInnerClass {
	public static void main(String[] args) {
		Outer o = new Outer();
		o.method();
	}
}

interface Inter {
	public void show1();
	public void show2();
}
//匿名內部類只針對重寫一個方法時候使用
class Outer {
	public void method() {
		/*new Inter(){
			public void show1() {
				System.out.println("show1");
			}

			public void show2() {
				System.out.println("show2");
			}
		}.show1();

		new Inter(){
			public void show1() {
				System.out.println("show1");
			}

			public void show2() {
				System.out.println("show2");
			}
		}.show2();*/

		Inter i = new Inter(){
			public void show1() {
				System.out.println("show1");
			}

			public void show2() {
				System.out.println("show2");
			}

			/*public void show3() {
				System.out.println("show3");
			}*/
		};

		i.show1();
		i.show2();
		//i.show3();						//匿名內部類是不能向下轉型的,因為沒有子類類名
	}
}

class Test2_NoNameInnerClass {
	public static void main(String[] args) {
		//Outer.method().show();			//鏈式程式設計,每次呼叫方法後還能繼續呼叫方法,證明呼叫方法返回的是物件
		Inter i = Outer.method();
		i.show();
	}
}
//按照要求，補齊程式碼
interface Inter { 
	void show(); 
}

class Outer { 
	//補齊程式碼 
	public static Inter method() {
		return new Inter() {
			public void show() {
				System.out.println("HelloWorld");
			}
		};
	}
}

//要求在控制檯輸出”HelloWorld”