Java基礎--->抽象類、接口、內部類、異常等

第一 抽象類

一、概括：

       當多個類出現相同功能，但是功能主體不同是，這樣就可以向上抽取，抽取時只抽取功能定義，而不抽取功能主體。這是我們就把抽取出來的功能主體因爲沒有具體的方法體，對於我們來說也就是看不懂的，用一個專業的詞來形容就是抽象，抽象用一個特殊的關鍵字abstract來修飾，特別說明下類中有抽象方法時那麼該類也就是抽象的，也必須用abstract來修飾。

二、抽象類的特點：

1、抽象方法一定在抽象類中。

2、抽象方法和抽象類都必須被abstract關鍵字修飾。

3、抽象類不可以用new創建對象。因爲調用抽象方法沒意義。

4、抽象類中的抽象方法要被使用，必須由子類複寫其所有的抽象方法後，建立子類對象調用。如果子類只覆蓋了部分抽象方法，那麼該子類還是一個抽象類。

總結：抽象類和一般類沒有太大的不同。該如何描述事物，就如何描述事物，只不過，該事物出現了一些看不懂的東西。這些不確定的部分，也是該事物的功能，需要明確出來。但是無法定義主體，通過抽象方法來表示。特殊：抽象類中可以不定義抽象方法，這樣做僅僅是不讓該類建立對象。

三、abstract 關鍵字，和哪些關鍵字不能共存。

1、final：被final修飾的類不能有子類。而被abstract修飾的類一定是一個父類。

2、private: 抽象類中的私有的抽象方法，不被子類所知，就無法被複寫。而抽象方法出現的就是需要被複寫。

3、static：如果static可以修飾抽象方法，那麼連對象都省了，直接類名調用就可以了。可是抽象方法運行沒意義。

四、抽象類中是否有構造函數？

有，抽象類是一個父類，要給子類提供實例的初始化。

/*
假如我們在開發一個系統時需要對員工進行建模，員工包含 3 個屬性：
姓名、工號以及工資。經理也是員工，除了含有員工的屬性外，另爲還有一個
獎金屬性。請使用繼承的思想設計出員工類和經理類。要求類中提供必要的方
法進行屬性訪問。

員工類：name id pay

經理類：繼承了員工，並有自己特有的bonus。


*/

class Employee
{
	private String name;
	private String id;
	private double pay;

	Employee(String name,String id,double pay)
	{
		this.name = name;
		this.id = id;
		this.pay = pay;
	}
	
	public abstract void work();

}



class Manager extends Employee
{
	private int bonus;
	Manager(String name,String id,double pay,int bonus)
	{
		super(name,id,pay);
		this.bonus = bonus;
	}
	public void work()
	{
		System.out.println("manager work");
	}
}

class Pro extends Employee
{
	Pro(String name,String id,double pay)
	{
		super(name,id,pay);
	}
	public void work()
	{
		System.out.println("pro work");
	}
}




class  
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");
	}
}

 第二 接口

一、概述：

接口：初期理解，可以認爲是一個特殊的抽象類，當抽象類中的方法都是抽象的，那麼該類可以通過接口的形式來表示。class用於定義類，interface 用於定義接口。

二、接口定義時，格式特點：

1、接口中常見定義：常量，抽象方法。

2、接口中的成員都有固定修飾符。

            常量：public static final

            方法：public abstract

記住：接口中的成員都是public的。

三、特點：

1、接口：是不可以創建對象的，因爲有抽象方法。
2、需要被子類實現，子類對接口中的抽象方法全都覆蓋後，子類纔可以實例化。否則子類是一個抽象類。
3、接口可以被類多實現，也是對多繼承不支持的轉換形式。java支持多實現。接口與接口之間可以多繼承。

interface Inter
{
	public static final int NUM = 3;
	public abstract void show();
}

interface InterA
{
	public abstract void show();
}

class Demo
{
	public void function(){}
}

class Test extends Demo implements Inter,InterA
{
	public void show(){}
}


interface A
{
	void methodA();
}
interface B //extends A
{
	void methodB();
}

interface C extends B,A
{
	void methodC();
}

class D implements C
{
	public void methodA(){}
	public void methodC(){}
	public void methodB(){}
}


class InterfaceDemo 
{
	public static void main(String[] args) 
	{
		Test t = new Test();
		System.out.println(t.NUM);
		System.out.println(Test.NUM);
		System.out.println(Inter.NUM);

	}
}

說明：

1、類與類之間不能對繼承，原因是多個父類中有同名函數，子類在運行的時候不知道運行那塊代碼。

2、java可以多實現，原因是接口都是抽象的，抽象方法沒有方法體，不管有沒有相同的函數，子類都只需要覆蓋一次就可以了。

3、接口與接口之間可以多繼承：因爲接口中都是抽象方法，不存在方法體，也都需要子類去覆蓋，所以不存在模糊的調用的。

四、接口的特點：

1、接口是對外暴露的規則

2、接口是程序的擴展功能

3、接口可以多實現

4、接口與接口之間可以多繼承

5、接口降低了代碼的耦合性

6、類與接口之間是實現關係，一個類可以繼承一個類的同時去實現多個接口。

注意：兩個或多個接口中不允許有返回值類型不同的同名函數

public class AB implements A, B {
	@Override
	public void method() {

	}

	public int method() {
		
	}

}

interface A {
	public abstract void method();
}

interface B {
	public abstract int method();
}

這代碼是有錯的，因爲在類實現了兩個接口後有兩個方法名相同，但是返回值類型不同的方法，這是沒有構成重載的，所以不能同時存在一個類中。

 第三 抽象類與接口的區別和聯繫

一、區別：

第一、與類的關係不同

1、抽象類是一種被子類繼承的關係（類與類之間單繼承）

2、接口與類之間是實現關係（一個類能實現多個接口）

3、接口與接口之間是繼承關係（接口之間可以多繼承）

第二、定義特點不同

1、抽象類可以定義變量、非抽象類、抽象類

變量：private、public、final、static等等修飾符

抽象方法：abstract(必須有)、public、static等等修飾符

2、接口可以定義常量、抽象類

常量：public static final（只能賦值一次）

方法：public abstract

3、權限不同：

抽象類可以有私有變量或方法（抽象方法不能爲私有），子類繼承抽象父類必須複寫全部的抽象方法

接口是公開(public)的，裏面不能有私有方法，因爲接口是對外暴露的，是提供給外界使用的；實現接口必須重寫接口中的全部抽象方法

4、成員不同：

抽象類中可以有自己的成員，也可以由非抽象的成員方法。

接口中只能有靜態的不能被修改的成員變量（即常量），而且所有成員方法皆爲抽象的。

5、變量不同：

抽象類中的變量默認是friendly型的，即包內的任何類都可以訪問它，而包外的任何類都不能訪問它(包括包外繼承了此類的子類)，其值可以在子類中重新定義，也可重新賦值。

接口中定義的變量是默認的public static final，且必須進行初始化即賦初值，並不可改變。

二、聯繫

1.其實接口是抽象類的延伸，可以將它看做是純粹的抽象類，就是說接口比抽象類還抽象。

2、抽象類和接口都必須被一個類（子類）複寫裏面的全部抽象方法。

3、接口和抽象類都不可創建對象，因爲其中含有抽象方法，需要被子類實現後，對接口中抽象方法全覆蓋後，子類纔可以實現實例化。

第四 內部類

一、概述：

內部類，顧名思義就會定義在一個類裏面的類就稱爲內部類。一個內部類可以定義在外部類的成員位置上，也可以定在函數內部作爲局部存在。

二、內部類的訪問規則：

1、內部類可以直接訪問外部類中的成員，包括私有。之所以可以直接訪問外部類中的成員，是因爲內部類中持有了一個外部類的引用，格式 外部類名.this

2、外部類要訪問內部類，必須建立內部類對象。

三、訪問格式：

1、當內部類定義在外部類的成員位置上，而且非私有，可以在外部其他類中。可以直接建立內部類對象。

格式
外部類名.內部類名  變量名 = 外部類對象.內部類對象;
Outer.Inner in = new Outer().new Inner();

2、當內部類在成員位置上，就可以被成員修飾符所修飾。比如，private：將內部類在外部類中進行封裝。static:內部類就具備static的特性。當內部類被static修飾後，只能直接訪問外部類中的static成員。出現了訪問侷限。

在外部其他類中，如何直接訪問static內部類的非靜態成員呢？new Outer.Inner().function();

在外部其他類中，如何直接訪問static內部類的靜態成員呢？uter.Inner.function();

注意：當內部類中定義了靜態成員，該內部類必須是static的。當外部類中的靜態方法訪問內部類時，內部類也必須是static的。

class Outer
{
	private static  int x = 3;

	
	static class Inner//靜態內部類
	{
		static void function()
		{
			System.out.println("innner :"+x);
		}
	}

	static class Inner2
	{
		void show()
		{
			System.out.println("inner2 show");
		}
	}

	public static void method()
	{
		//Inner.function();
		new Inner2().show();
	}

}


class  InnerClassDemo2
{
	public static void main(String[] args) 
	{
		Outer.method();
		//Outer.Inner.function();
		//new Outer.Inner().function();
		//直接訪問內部類中的成員。
//		Outer.Inner in = new Outer().new Inner();
//		in.function();
	}
}

四、內部類定義原則：

1、當描述事物是，事物的內部還有事物，則該事物用內部類來描述。如人與心臟的關係。

2、何時定義內部類：當一個類需要直接訪問另一個的成員時，則將這個類放在另一個類的內部，並將此類封裝。

局部內部類：當內部類只在外部類中的某個方法中，創建了這個類型的對象時，且僅使用了一次，那麼可在這個方法中定義局部類。

注：

1、局部內部類不可用public或者private訪問修飾符聲明，它的作用域被限定在了聲明這個局部類的代碼塊中

2、局部類的優勢：

a.對外界完全隱藏，即使此方法所在的類也不可訪問，也就是說，除此方法外，無任何方法知道它的存在。

b.可訪問包含他們的外部類，因還持有外部類的引用；還可訪問局部變量，但是局部變量必須被聲明爲final。

需要注意：局部內部類不可悲成員修飾符修飾，如static

class Outer
{
	int x = 3;

	void method(final int a)
	{
		final int y = 4;
		class Inner
		{
			void function()
			{
				System.out.println(y);
			}
		}
	
		new Inner().function();
		
	}
}


class  InnerClassDemo3
{
	public static void main(String[] args) 
	{
		Outer out = new Outer();
		out.method(7);
		out.method(8);
	}

}

在上面的代碼中既傳了7（out.method(7);）又傳了8（out.method(8);）這是可以的，因爲函數中的final int a是局部變量，加載在棧內存中，隨着對象的消亡而消亡了。

五、匿名內部類：

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

2、定義匿名內部類的前提：內部類必須是繼承一個類或者實現接口。

3、匿名內部類的格式：  new 父類或者接口(){定義子類的內容}

4、其實匿名內部類就是一個匿名子類對象。而且這個對象有點胖。可以理解爲帶內容的對象。

5、匿名內部類中定義的方法最好不要超過3個。

abstract class AbsDemo
{
	abstract void show();
	
}


class Outer
{
	int x = 3;

	/*
	class Inner extends AbsDemo
	{
		int num = 90;
		void show()
		{
			System.out.println("show :"+num);
		}
		void abc()
		{
			System.out.println("hehe");
		}
	}
	*/

	public void function()
	{
		//AbsDemo a = new Inner();
//		Inner in = new Inner();
//		in.show();
//		in.abc();
	

		AbsDemo d = new AbsDemo()//new AbsDemo()匿名內部類的子類對象，多態
		{
			int num = 9;
			void show()
			{
				System.out.println("num==="+num);
			}
			void abc()
			{
				System.out.println("haha");
			}
		};

		d.show();
		//d.abc();//編譯失敗;不能向下轉型
	}
}



class InnerClassDemo4 
{
	public static void main(String[] args) 
	{
		new Outer().function();
	}
}

練習：

interface Inter
{
	void method();
}

class Test 
{
	//補足代碼。通過匿名內部類。
	/*
	static class Inner implements Inter
	{
		public void method()
		{
			System.out.println("method run");
		}
	}
	*/

	static Inter function()
	{
		return new Inter()
		{
			public void method()
			{
				System.out.println("method run");
			}
		};
	}

}



class InnerClassTest 
{
	public static void main(String[] args) 
	{

		//Test.function():Test類中有一個靜態的方法function。
		//.method():function這個方法運算後的結果是一個對象。而且是一個Inter類型的對象。
		//因爲只有是Inter類型的對象，纔可以調用method方法。


		Test.function().method();
		

//		Inter in = Test.function();
//		in.method();


		show(new Inter()
		{
			public void method()
			{
				System.out.println("method show run");
			}
		});

	}

	public static void show(Inter in)
	{
		in.method();
	}
}

class InnerTest
{

	public static void main(String[] args)
	{
		new Object()
		{
			public void function()
			{
				
			}
			
		}.function();


	}
}

 第五 模版方法設計模式

什麼是模版方法呢？
        在定義功能時，功能的一部分是確定的，但是有一部分是不確定，而確定的部分在使用不確定的部分，那麼這時就將不確定的部分暴露出去。由該類的子類去完成。

/*
需求：獲取一段程序運行的時間。
原理：獲取程序開始和結束的時間並相減即可。

獲取時間：System.currentTimeMillis();

當代碼完成優化後，就可以解決這類問題。

這種方式，模版方法設計模式。



*/

abstract class GetTime
{
	public final void getTime()
	{
		long start = System.currentTimeMillis();

		runcode();

		long end = System.currentTimeMillis();

		System.out.println("毫秒："+(end-start));
	}
	public abstract void runcode();

}


class SubTime extends GetTime
{

	public void runcode()
	{
		
		for(int x=0; x<4000; x++)
		{
			System.out.print(x);
		}
	}
}


class  TemplateDemo
{
	public static void main(String[] args) 
	{
		//GetTime gt = new GetTime();
		SubTime gt = new SubTime();
		gt.getTime();
	}
}

 第六異常

一、異常概述：就是程序在運行時出現不正常情況。
二、異常由來：問題也是現實生活中一個具體的事物，也可以通過java的類的形式進行描述。並封裝成對象。其實就是java對不正常情況進行描述後的對象體現。

1、對於問題的劃分：兩種：一種是嚴重的問題，一種非嚴重的問題。

2、對於嚴重的，java通過Error類進行描述。對於Error一般不編寫針對性的代碼對其進行處理。

3、對與非嚴重的，java通過Exception類進行描述。對於Exception可以使用針對性的處理方式進行處理。

    異常有兩種：
編譯時被檢測異常
該異常在編譯時，如果沒有處理(沒有拋也沒有try)，編譯失敗。
該異常被標識，代表這可以被處理。
運行時異常(編譯時不檢測)
在編譯時，不需要處理，編譯器不檢查。
該異常的發生，建議不處理，讓程序停止。需要對代碼進行修正。

4、無論Error或者Exception都具有一些共性內容。比如：不正常情況的信息，引發原因等。

5、異常的好處：將問題進行封裝；將正常流程代碼和問題處理代碼相分離，方便於閱讀。

6、異常的注意事項：

     在子父類覆蓋時：子類拋出的異常必須是父類的異常的子類或者子集；如果父類或者接口沒有異常拋出時，子類覆蓋出現異常，只能try不能拋。

三、異常的處理：

異常處理的任務：將控制權從錯誤產生的地方轉移給能處理錯誤這種情況的錯誤處理器。

若函數上聲明瞭異常，調用者需進行處理，處理方法可以throw，可以try。

1、對捕獲的異常對象進行常見方法的操作：

trrows Exception：拋出異常

try-catch-finally：捕獲異常 ---- java中提供了特有的語句進行處理。

String getMessage();獲得異常信息

2、throw和throws的用法：

1）throw：定義在函數內，用於拋出異常對象。注：throw單獨存在時，下面不要定義語句，因爲執行不到，編譯失敗。

2）throws：定義在函數上，用於跑出異常類，可拋多個，用逗號隔開。

注：當函數內有throw拋出異常對象，必須給出對應的處理動作，若並未進行try處理，需在函數上聲明，否則編譯失敗。

一般函數出現異常，需在函數上聲明，但RuntimeException除外，若在函數內拋出此異常，函數上可不聲明。

3、異常處理語句：

結合方式：

① try-chatch   ②try-finally  ③try-catch-finally

注：

①、在函數上聲明異常：便於提高安全性，讓調用者進行處理，若不處理，則編譯失敗。

②、finally中定義的通常爲：關閉資源代碼，因爲資源必須被釋放。

③、有一種情況不會執行finally，即出現System.exit(0);這條語句，後面的finally不會執行，因爲這個代表系統退出嗎，JVM結束。

4、多異常的處理：

1）聲明異常時，建議聲明更爲具體的異常，這樣處理更具體。

注：拋出幾個具體的問題處理時，就具體處理哪些問題，而不是再加上catch(Exception e){...}讓JVM自己將問題解決後再繼續運行，那麼調用者將不知道發生了什麼問題。

2）原則：

對方聲明幾個異常，就對應幾個catch塊，不要定義多餘catch，若多個catch塊中的異常出現繼承關係，父類異常catch塊，放最下面（最大，處理更多）。

3）建議：

在進行catch處理時，catch中一定要定義具體處理方式，不要簡單的定義一句：e.printStatckTrace();，也不要簡單的打印一句。

遇到異常要怎麼處理呢？常規做法是不打印異常信息，因爲即時打印了，用戶也無法解決掉，最好是將問題或信息記錄下來，並存儲爲異常日誌文件，便於程序員管理查閱，並及時修正代碼，管理程序。

四、自定義異常：

1、概述：

因爲項目中會出現特有問題，而這些問題並未被java所描述並封裝成對象，所以這些特有問題可按java中對問題封裝的思想，將特有問題進行定義的異常封裝。

2、一般繼承Exception或RuntimeException的原因：

1）異常體系有一個特點：異常類和異常對象都被拋出，他們都具有可拋性。這個可拋性是Throwable這個體系單獨有的特點，只有此體系中的類和對象纔可被throws和throw操作。

2）爲了讓該類具備操作異常的共性方法。

3、定義異常信息：

由於父類中把異常信息的操作完成了，所以子類只需要在構造函數時，將異常信息傳遞給父類，通過super語句，則可直接用getMessage方法，自動自定義的異常。

class FuShuException extends Exception //getMessage();
{
	private int value;

	FuShuException()
	{
		super();
	}
	FuShuException(String msg,int value)
	{
		super(msg);
		this.value = value;
	}

	public int getValue()
	{
		return value;
	}

}



class Demo
{
	int div(int a,int b)throws FuShuException
	{
		if(b<0)
			throw new FuShuException("出現了除數是負數的情況------ / by fushu",b);//手動通過throw關鍵字拋出一個自定義異常對象。

		return a/b;
	}
}


class  ExceptionDemo3
{
	public static void main(String[] args) 
	{
		Demo d = new Demo();
		try
		{
			int x = d.div(4,-9);
			System.out.println("x="+x);		
		}
		catch (FuShuException e)
		{
			System.out.println(e.toString());
			//System.out.println("除數出現負數了");
			System.out.println("錯誤的負數是："+e.getValue());
		}
		
		

		System.out.println("over");

	}
}

/*
class Throwable
{
	private String message;
	Throwable(String message)
	{
		this.message = message;
	}

	public String getMessage()
	{
		return message;
	}
}

class Exception extends Throwable
{
	Exception(String message)
	{
		super(message);
	}
}


class Person
{
	String name;
	Person(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return name;
		}
}

class Student extends Person
{
	Student (String name)
	{
		super(name);
	}
}

new Sttdent("lisi").getName();

*/

五、異常處理原則

1、處理方式：throw或throws

2、調用到拋出異常的功能時，拋幾個，處理幾個，一個try可以對應多個catch

3、多個catch，父類catch放在最下面。

4、catch內需要定義針對性的處理方式，不要定義printStackTrace，輸出語句也不要不寫，當捕獲到異常，本功能處理不了時，可繼續在catch中拋出

/*
畢老師用電腦上課。

開始思考上課中出現的問題。


比如問題是
	電腦藍屏。
	電腦冒煙。

要對問題進行描述，封裝成對象。


可是當冒煙發生後，出現講課進度無法繼續。

出現了講師的問題：課時計劃無法完成。


*/

class LanPingException extends Exception
{
	LanPingException(String message)
	{
		super(message);
	}
}

class MaoYanException extends Exception
{
	MaoYanException(String message)
	{
		super(message);
	}
}


class NoPlanException extends Exception
{
	NoPlanException(String msg)
	{
		super(msg);
	}
}

class Computer
{
	private int state = 3;
	public void run()throws LanPingException,MaoYanException
	{
		if(state==2)
			throw new LanPingException("藍屏了");
		if(state==3)
			throw new MaoYanException("冒煙了");

		System.out.println("電腦運行");
	}
	public void reset()
	{
		state = 1;
		System.out.println("電腦重啓");
		
	}
}

class Teacher
{
	private String name;
	private Computer cmpt;

	Teacher(String name)
	{
		this.name = name;
		cmpt = new Computer();

	}

	public void prelect()throws NoPlanException
	{
		try
		{
			cmpt.run();			
		}
		catch (LanPingException e)
		{
			cmpt.reset();
		}
		catch (MaoYanException e)
		{
			
			test();
			throw new NoPlanException("課時無法繼續"+e.getMessage());
			
		}
		System.out.println("講課");
	}
	public void test()
	{
		System.out.println("練習");
	}

}



class ExceptionTest 
{
	public static void main(String[] args) 
	{
		Teacher t = new Teacher("畢老師");
		try
		{
			t.prelect();
		}
		catch (NoPlanException e)
		{
			System.out.println(e.toString());
			System.out.println("換老師或者放假");
		}
		
	}
}