JAVA基礎之內部類

內部類：定義在類中的類叫內部類。


內部類的訪問特點：
1.內部類可以直接訪問外部類中的成員。
2.外部類要訪問內部類，必須先創建內部類的對象。


內部類的使用：一般用於類的設計。
分析事物時，發現該事物描述中還有事物，而且這個事物還在訪問描述事物的內容。
這時就可以將事物中的事物定義成內部類來描述。

比如：

class Love
{
	private String love="隨意";
	private static  String like="隨便";//因爲靜態只能訪問靜態，所以like變量也得是靜態的。
	class Like
	{
		void show()
		{
			System.out.println("show run..."+love);
		}
	}
	static class love//這是一個靜態的內部類，相當於一個外部類。
	{
		void show()
		{
			System.out.println("show run..."+like);
		}
		static void like()//如果內部類中定義了靜態成員，那麼該內部類也必須是靜態的。
		//因爲靜態成員是隨着類的加載而存在的，當外部類開始加載的時候，內部類不是靜態就無法存在
		//更談不上訪問內部類中的靜態成員。
		{
			System.out.println("遇見"+like);
		}
	}
	public void getLove()
	{
		Like l =new Like();
		l.show();
	}
}

內部類直接訪問外部類中的成員：
內部類需持有外部類的引用。格式爲：外部類名.this

比如

class orange
{
	String love="煩";
	class apple
	{
		String love="迷茫";
		void show()
		{
			String love="去";
			System.out.println(love);//方法存在與棧內存中，當棧內存與堆內存存在相同變量時
			//獲取的是棧內存中的變量值，所以這個打印出來的是“茵茵”
			System.out.println(this.love);//用了this關鍵字，輸出的就是對象中的變量值。
			//所以這句輸出的是“迷茫”
			System.out.println(orange.this.love);//用了外部類名就可以輸出（調用）外部類的成員變量。
			//所以這句輸出的是“煩”
		}
	}
	public void work()
	{
		new apple().show();//這是匿名對象調用。
	}
}

內部類也可以存放在局部位置上。
內部類在局部位置上只能訪問局部中被final修飾的局部變量。
比如：

class hello
{
	String a="哈哈";
	void show()
	{
		int b=8;//在JDK8版本以前，這個局部變量必須要加final關鍵字才能被內部類的方法所訪問，否則就會報錯。
		//因爲方法執行完後就彈棧了，內部類中的方法就訪問不到這個局部變量。
		//加final關鍵字的意思就是固定這個值。
		//雖然JDK8以後不用加final關鍵字也能編譯運行，但是這個變量值依然不可更改，更改即報錯。
		class world
		{
			void geta()
			{
				System.out.println(b);
			}
		}
		new world().geta();
	}
}

匿名內部類：
其實就是內部類的簡寫格式。

他的前提是：
內部類必須繼承或者實現一個外部類或者接口。


匿名內部類：其實就是一個匿名子類對象。
格式：new 父類名or接口名(){子類內容}


比如：

abstract class Why
{
	abstract void show();
}
class Who
{
	int num=7;
	class You extends Why//這是普通內部類繼承外部類。
	{
		void show()
		{
			System.out.println(num);
		}
	}
	void work()
	{
		new You().show();
		new Why()//這是匿名內部類，直接用父類名創建子類對象，並覆蓋父類中的方法。
		{
			void show()
			{
				System.out.println(num);
			}
		}.show();//.show();就是在調用匿名內部類中的方法。
	}
}

匿名內部類的應用場景之一：
當函數參數是接口類型時，而且接口中的方法不超過三個。
可以用匿名內部類作爲實際參數進行傳遞。
比如：

interface Inter
{
	void show1();
	void show2();
}
class Niming
{
	class Inner implements Inter//這是一般方法。
	{
		public void show1()
		{
			System.out.println("真的愛你");
		}
		public void show2()
		{
			System.out.println("喜歡你");
		}
	}
	void show3()
	{
		Inner in=new Inner();
		in.show1();
		in.show2();
		System.out.println("---------");
		Inter ia=new Inter()//這是匿名內部類的方法。當父類（接口）方法超過一個時可用多態形式命名新對象。
		{//然後以父類類型命名匿名對象進行調用多個方法。
			public void show1()
			{
				System.out.println("真的愛你");
			}
			public void show2()
			{
				System.out.println("喜歡你");
			}
		};
		ia.show1();
		ia.show2();
	}
}
class TangYi
{
	void show()
	{
		new Object()
		{
			void show1()
			{
				System.out.println("狂人山莊");
			}
		}.show1();//這個可以運行。
		Object obj=new Object()
		{
			void show2()
			{
				System.out.println("樂與怒");
			}
		};
		obj.show2();//這個會掛掉，編譯失敗。
		/*因爲雖然創建的是子類對象，但是類類型是父類的，也就是多態形式。
		Object是沒有定義任何方法的，所以show2()的方法就是子類特有的。
		父類類型的子類對象當然訪問不到子類的特有內容。
		（匿名內部類這個子類對象被向上轉型成了Object類型，這樣就無法訪問子類的特有方法）*/
	}
}
class NeiBulei  
{
	public static void main(String[] args) 
	{
		Love l= new Love();
		l.getLove();
		//還有一種不多見的訪問形式，就是直接訪問外部類中的內部類中的成員。比如：
		Love.Like a=new Love().new Like();//所屬關係一定要寫對，否則無法訪問。
		a.show();
		System.out.println("---------");
		//如果內部類是靜態的，這時就相當於一個外部類。
		Love.love b=new Love.love();
		b.show();
		System.out.println("---------");
		//如果內部類是靜態的，而且內部類中的成員也是靜態的。那我們可以直接類名調用。
		Love.love.like();
		System.out.println("---------");
		new orange().work();//匿名對象調用。
		System.out.println("---------");
		new hello().show();
		System.out.println("---------");
		new Who().work();
		System.out.println("---------");
		new	Niming().show3();
		System.out.println("---------");
		show(new Inter()//這裏可以看出，如果方法過多，閱讀性就相當差了。
		{//而且這裏和內部類其實沒什麼關係了，只是一個匿名子類，也就是匿名對象。
			public void show1()
			{
				System.out.println("情人");
			}
			public void show2()
			{
				System.out.println("海闊天空");
			}
		});
		System.out.println("---------");
		new TangYi().show();
	}
	public static void show(Inter in)
	{
		in.show1();
		in.show2();
	}
}