JAVA中的 內部類

1. 內部類

1.靜態內部類

• 1.聲明在類體部，方法體外，並且使用static修飾的內部類
• 2.訪問特點可以類比靜態變量和靜態方法
• 3.脫離外部類的實例獨立創建
  在外部類的外部構建內部類的實例
  new Outer.Inner();
  在外部類的內部構建內部類的實例
  new Inner();
• 4.靜態內部類體部可以直接訪問外部類中所有的靜態成員，包含私有

public class StaticInnerClassDemo {
   
   public static void main(String[] args) {
   	// 實例化外部類。
   	Foo foo = new Foo();
   	// 如何實例化內部類。
   	Koo koo = new Foo.Koo();
   	System.out.println(koo.b);
   	koo.show();

   	}

   }


class Foo{
   		
   private static int a = 10;
   // 內部類
   static class Koo{
   	public int b = 20;
   	public void show(){
   	System.out.println("hello innerclass"+a);// 能夠訪問外部靜態變量。
   	}
   }
}

2.成員內部類

• 1.沒有使用static修飾的內部類。
• 2.在成員內部類中不允許出現靜態變量和靜態方法的聲明。
  static只能用在靜態常量的聲明上。
• 3.成員內部類中可以訪問外部類中所有的成員(變量，方法)，包含私有成員，如果在內部類中定義有和外部類同名的實例變量，訪問：
  OuterClass.this.outerMember;
• 4.構建內部類的實例，要求必須外部類的實例先存在
  外部類的外部/外部類的靜態方法：new Outer().new Inner();
  外部類的實例方法：
  new Inner();
  this.new Inner();

public class InnerClassDemo {
	
	public static void main(String[] args){
		Joo joo = new Joo();
		// 獲取內部類實例
				Noo noo = joo.new Noo();
				System.out.println(noo.b);
				noo.show();

			}

		}

		// 外部類
		class Joo{
			private int a = 10;
			class Noo{
				public  int b = 20;
				public void show(){
					System.out.println(a+b);
				}
			}
			
			public void show(){
				Noo noo = new Noo();
				System.out.println(noo.b);
	}

}

3.局部內部類

• 1.定義在方法體，甚至比方法體更小的代碼塊中
• 2.類比局部變量。
• 3.局部內部類是所有內部類中最少使用的一種形式。
• 4.局部內部類可以訪問的外部類的成員根據所在方法體不同。
  如果在靜態方法中：
  可以訪問外部類中所有靜態成員，包含私有
  如果在實例方法中：
  可以訪問外部類中所有的成員，包含私有。
  局部內部類可以訪問所在方法中定義的局部變量，但是要求局部變量必須使用final修飾。

public class LocalInnerClass {
	
		public static void main(String[] args) {
		   
			int a = 20;
			class Hoo{
				int b = 20;
				public void show(){
					System.out.println(b+a);
//					System.out.println(a++);// 內部類允許訪問外部的局部變量，但不能改變其值。
				}
			}
			Hoo hoo = new Hoo();
			hoo.show();
	}
	
}

4.匿名內部類

• 1.沒有名字的局部內部類。
• 2.沒有class,interface,implements,extends關鍵字
• 3.沒有構造器。
• 4.一般隱式的繼承某一個父類或者實現某一個接口

public class AnonInnerClassDemo {

	public static void main(String[] args) {
		// 實例化匿名內部類。
		Aoo aoo = new Aoo(){
			public void show(){
				System.out.println("hello zhangsan");
				
			}
		};
		aoo.show();
		
		System.out.println("***************");
		new Aoo(){
			public void show(){
				System.out.println("匿名內部類");
			}
		}.show();
		
		// 匿名內部類，重寫抽象類方法。
		new Coo(){
			@Override
			public void getCoo() {
				System.out.println("匿名內部類，重寫抽象方法");
			}
		}.getCoo();
		
		//匿名內部類，重寫接口中的方法。
		new Doo() {
			@Override
			public void getDoo() {
               System.out.println("重寫接口中的方法");				
			}
		}.getDoo();
		
		// 匿名內部類獲取實例。
		Doo doo = new Doo() {
			@Override
			public void getDoo() {
				
			}
		};
		doo.getDoo();

	}

}

// 普通類。
class Aoo{
	public int a = 10;
	public void show(){
		System.out.println(a);
	}
}
// 子類繼承父類。
class Boo extends Aoo{
	public void show(){
		System.out.println("hello world");
	}
}
// 抽象類。
abstract class Coo{
	public abstract void getCoo();
}

// 接口
interface Doo{
	public abstract void getDoo();
}