1.接口和抽象類的區(qū)別

相似點(diǎn)：

（1）接口和抽象類都不能被實(shí)例化

（2）實(shí)現(xiàn)接口或繼承抽象類的普通子類都必須實(shí)現(xiàn)這些抽象方法

不同點(diǎn)：

（1）抽象類可以包含普通方法和代碼塊，接口里只能包含抽象方法，靜態(tài)方法和默認(rèn)方法，

（2）抽象類可以有構(gòu)造方法，而接口沒有

（3）抽象類中的成員變量可以是各種類型的，接口的成員變量只能是 public static final 類****型的，并且必須賦值

2.重載和重寫的區(qū)別

方法的重載和重寫都是實(shí)現(xiàn)多態(tài)的方式，

重載實(shí)現(xiàn)的是編譯時(shí)的多態(tài)性，
而重寫實(shí)現(xiàn)的是運(yùn)行時(shí)的多態(tài)性。

重載發(fā)生在同一個(gè)類中，方法名相同、參數(shù)列表、返回類型、權(quán)限修飾符可以不同

重寫發(fā)生在子類中，方法名相、參數(shù)列表、返回類型都相同，權(quán)限修飾符要大于父類方法，聲明異常范圍要小于父類方法，但是final和private修飾的方法不可重寫

3.==和equals的區(qū)別

==比較基本類型，比較的是值， 
==比較引用類型，比較的是內(nèi)存地址

equlas是Object類的方法，本質(zhì)上與==一樣，但是有些類重寫了equals方法，比如String的equals被重寫后，比較的是字符值，另外重寫了equlas后，也必須重寫hashcode()方法

疑問？

>為什么重寫equal了必須重寫hashcode?

equals() 方法和 hashcode() 方法是 java.lang.Object 類的兩個(gè)重要的方法，Java中多數(shù)類都會(huì)重寫 Object 類的 equals() 方法。

在實(shí)際應(yīng)用中，如果我們自定義的類需要進(jìn)行比較操作，就一定也需要重寫 equals() 方法。那么為什么重寫 equals()方法時(shí)，必須要求重寫 hashCode() 方法呢？

首先， equals() 方法和 hashcode() 方法間的關(guān)系是這樣的：

1、如果兩個(gè)對(duì)象相同（即：用 equals 比較返回true），那么它們的 hashCode 值一定要相同；

2、如果兩個(gè)對(duì)象的 hashCode 相同，它們并不一定相同（即：用 equals 比較返回 false）；

上面這兩句話，如果明白【散列表】的結(jié)構(gòu)，就一定會(huì)很明白，這里只簡(jiǎn)單提一句：散列表同時(shí)運(yùn)用了數(shù)組和鏈表。

《Effective java》一書中這樣說到：在每個(gè)覆蓋了 equals() 方法的類中，也必須覆蓋 hashCode() 方法，如果不這樣做的話，就會(huì)違反 Object.hashCode 的通用的約定，從而導(dǎo)致該類無法結(jié)合所有基于散列的集合一起正常運(yùn)作，這樣的集合包括HashMap，HashSet 和 HashTable。

如果只重寫了 equals 方法，那么默認(rèn)情況下，Set 進(jìn)行去重操作時(shí)，會(huì)先判斷兩個(gè)對(duì)象的 hashCode 是否相同，此時(shí)因?yàn)闆]有重寫 hashCode 方法，所以會(huì)直接執(zhí)行 Object 中的 hashCode 方法，而 Object 中的 hashCode 方法對(duì)比的是兩個(gè)不同引用地址的對(duì)象，所以結(jié)果是 false，那么 equals 方法就不用執(zhí)行了，直接返回的結(jié)果就是 false：兩個(gè)對(duì)象不是相等的，于是就在 Set 集合中插入了兩個(gè)相同的對(duì)象。?

但是，如果在重寫 equals 方法時(shí)，也重寫了 hashCode 方法，那么在執(zhí)行判斷時(shí)會(huì)去執(zhí)行重寫的 hashCode 方法，此時(shí)對(duì)比的是兩個(gè)對(duì)象的所有屬性的 hashCode 是否相同，于是調(diào)用 hashCode 返回的結(jié)果就是 true，再去調(diào)用 equals 方法，發(fā)現(xiàn)兩個(gè)對(duì)象確實(shí)是相等的，于是就返回 true 了，因此 Set 集合就不會(huì)存儲(chǔ)兩個(gè)一模一樣的數(shù)據(jù)了，于是整個(gè)程序的執(zhí)行就正常了。

總結(jié)
hashCode 和 equals 兩個(gè)方法是用來協(xié)同判斷兩個(gè)對(duì)象是否相等的，采用這種方式的原因是可以提高程序插入和查詢的速度，如果在重寫 equals 時(shí)，不重寫 hashCode，就會(huì)導(dǎo)致在某些場(chǎng)景下，例如將兩個(gè)相等的自定義對(duì)象存儲(chǔ)在 Set 集合時(shí)，就會(huì)出現(xiàn)程序執(zhí)行的異常，為了保證程序的正常執(zhí)行，所以我們就需要在重寫 equals 時(shí)，也一并重寫 hashCode 方法才行。

答案來源

4.Java異常處理機(jī)制

4.1Error和Exception的區(qū)別:

Error和Exception都有一個(gè)共同的根類是Throwable類。

Error是系統(tǒng)中的錯(cuò)誤，程序員是不能改變的和處理的，一般是指與虛擬機(jī)相關(guān)的問題，如系統(tǒng)崩潰，虛擬機(jī)錯(cuò)誤，內(nèi)存空間不足，方法調(diào)用棧溢等。對(duì)于這類錯(cuò)誤的導(dǎo)致的應(yīng)用程序中斷，僅靠程序本身無法恢復(fù)和和預(yù)防，遇到這樣的錯(cuò)誤，建議讓程序終止。因此我們編寫程序時(shí)不需要關(guān)心這類錯(cuò)誤。

Exception，也就是我們經(jīng)常見到的一些異常情況，表示程序可以處理的異常，可以捕獲且可能恢復(fù)。遇到這類異常，應(yīng)該盡可能處理異常，使程序恢復(fù)運(yùn)行，而不應(yīng)該隨意終止異常。

異常分類
總體上我們根據(jù)Javac對(duì)異常的處理要求，將異常類分為2類。

我們常說的異常是狹義上的：就是指Exception及其子類，但是廣義上的異常是包括Exception和Error；

Java的異常(包括Exception和Error)從廣義上分為檢查異常（checked exceptions）和非檢查的異常（unchecked exceptions）。

其中根據(jù)Exception異常進(jìn)行劃分，可分為運(yùn)行時(shí)異常和非運(yùn)行時(shí)異常。

需要明確的是：檢查和非檢查是對(duì)于javac來說的，這樣就很好理解和區(qū)分了。

檢查異常
What:什么是檢查異常(checked exception)?

就是編譯器要求你必須處置的異常。不知道你編程的時(shí)候有沒有遇到過，你寫的某段代碼，編譯器要求你必須要對(duì)這段代碼try…catch，或者throws exception，如果你遇見過，沒錯(cuò)，這就是檢查異常，也就是說，你代碼還沒運(yùn)行呢，編譯器就會(huì)檢查你的代碼，會(huì)不會(huì)出現(xiàn)異常，要求你對(duì)可能出現(xiàn)的異常必須做出相應(yīng)的處理。

javac強(qiáng)制要求程序員為這樣的異常做預(yù)備處理工作（使用try…catch…finally或者throws）。在方法中要么用try-catch語句捕獲它并處理，要么用throws子句聲明拋出它，否則編譯不會(huì)通過。這樣的異常一般是由程序的運(yùn)行環(huán)境導(dǎo)致的。因?yàn)槌绦蚩赡鼙贿\(yùn)行在各種未知的環(huán)境下，而程序員無法干預(yù)用戶如何使用他編寫的程序，于是程序員就應(yīng)該為這樣的異常時(shí)刻準(zhǔn)備著。如SQLException , IOException,ClassNotFoundException 等。

    比如:我們調(diào)用日期格式化類解析字符串的時(shí)候;

How:怎樣處理檢查異常（checked exception）?

    1、繼續(xù)拋出，消極的方法，一直可以拋到j(luò)ava虛擬機(jī)來處理，就是通過throws Exception拋出。2、用try...catch捕獲注意，對(duì)于檢查的異常必須處理，或者必須捕獲或者必須拋出

Where:檢查異常有哪些呢？

除了RuntimeException與其子類，以及錯(cuò)誤（Error），其他的都是檢查異常（絕對(duì)的大家族）。

非檢查異常
What:什么是非檢查異常（unchecked exceptions）？

編譯器不要求強(qiáng)制處置的異常，雖然你有可能出現(xiàn)錯(cuò)誤，但是編譯器不會(huì)在編譯的時(shí)候檢查，沒必要，也不可能。

javac在編譯時(shí)，不會(huì)提示和發(fā)現(xiàn)這樣的異常，不要求在程序處理這些異常。所以如果愿意，我們可以編寫代碼處理（使用try…catch…finally）這樣的異常，也可以不處理。

對(duì)于這些異常，我們應(yīng)該修正代碼，而不是去通過異常處理器處理。這樣的異常發(fā)生的原因多半是代碼寫的有問題。如除0錯(cuò)誤ArithmeticException，錯(cuò)誤的強(qiáng)制類型轉(zhuǎn)換錯(cuò)誤ClassCastException，數(shù)組索引越界ArrayIndexOutOfBoundsException，使用了空對(duì)象NullPointerException等等。

How:對(duì)非檢查的異常(unchecked exception )怎樣處理?

    1、用try...catch捕獲2、繼續(xù)拋出3、不處理4、通過代碼處理一般我們是通過代碼處理的，因?yàn)槟愫茈y判斷會(huì)出什么問題，而且有些異常你也無法運(yùn)行時(shí)處理，比如空指針，需要人手動(dòng)的去查找。而且，捕捉異常并處理的代價(jià)遠(yuǎn)遠(yuǎn)大于直接拋出。

Why:為什么有非檢查異常？

你想想非檢查異常都有哪些？
NullPointerException，IndexOutOfBoundsException，VirtualMachineError等，這些異常你編譯的時(shí)候檢查嗎？再說了，明明可以運(yùn)行時(shí)檢查，都在編譯的時(shí)候檢查，你寫的代碼還能看嗎？而且有些異常只能在運(yùn)行時(shí)才能檢查出來，比如空指針，堆溢出等。

Where:非檢查異常有哪些？

RuntimeException與其子類，以及錯(cuò)誤（Error）。

Exception異常劃分
Exception異常進(jìn)行劃分，它可分為運(yùn)行時(shí)異常和編譯期異常。

運(yùn)行時(shí)異常：
是RuntimeException類及其子類異常，如NullPointerException(空指針異常)、IndexOutOfBoundsException(下標(biāo)越界異常)等，這些異常是非檢查異常，程序中可以選擇捕獲處理，也可以不處理。這些異常一般是由程序邏輯錯(cuò)誤引起的，程序應(yīng)該從邏輯角度盡可能避免這類異常的發(fā)生。

運(yùn)行時(shí)異常的特點(diǎn)是Java編譯器不會(huì)檢查它，也就是說，當(dāng)程序中可能出現(xiàn)這類異常，即使沒有用try-catch語句捕獲它，也沒有用throws子句聲明拋出它，也會(huì)編譯通過。

編譯期異常：
是RuntimeException以外的異常，類型上都屬于Exception類及其子類。從程序語法角度講是必須進(jìn)行處理的異常，如果不處理，程序就不能編譯通過。如IOException、SQLException等以及用戶自定義的Exception異常，一般情況下不要自定義檢查異常。

4.2常見異常

java.lang.RuntimeException: 運(yùn)行時(shí)異常

ClassCastException: 類類型轉(zhuǎn)換異常，當(dāng)試圖將對(duì)象強(qiáng)制轉(zhuǎn)換為不是實(shí)例的子類時(shí)，拋出該異常；

ArrayIndexOutOfBoundsException: 數(shù)組下標(biāo)越界異常，當(dāng)你使用不合法的索引訪問數(shù)組時(shí)會(huì)拋出該異常；

NullPointerException: 空指針異常，通過null進(jìn)行方法和屬性調(diào)用會(huì)拋出該異常；

ArithmeticException: 算術(shù)運(yùn)算異常，除數(shù)為0，拋出該異常；

NumberFormatException: 數(shù)字轉(zhuǎn)換異常，當(dāng)試圖將一個(gè)String轉(zhuǎn)換為指定的數(shù)字類型，而該字符串確不滿足數(shù)字類型要求的格式時(shí)，拋出該異常；

InputMismatchException: 輸入不匹配異常，輸入的值數(shù)據(jù)類型與設(shè)置的值數(shù)據(jù)類型不能匹配。

4.3異常處理的處理機(jī)制

在編寫程序時(shí)，經(jīng)常要在可能出現(xiàn)錯(cuò)誤的地方加上檢測(cè)的代碼，如進(jìn)行x/y運(yùn)算時(shí)，要檢測(cè)分母為0，數(shù)據(jù)為空，輸入的不是數(shù)據(jù)而是字符等。過多的if-else分支會(huì)導(dǎo)致程序的代碼加長(zhǎng)、臃腫，可讀性差。因此采用異常處理機(jī)制。

在編寫代碼處理異常時(shí)，對(duì)于檢查異常/非檢查異常，都有2種不同的處理方式：

            1、使用try...catch...finally語句塊處理它。2、在函數(shù)簽名中使用throws 聲明交給函數(shù)調(diào)用者caller去解決。

比如現(xiàn)有一輛車,這個(gè)車你可以是方法,這輛車在可能存在各種風(fēng)險(xiǎn),那么對(duì)于這些風(fēng)險(xiǎn)的處理方式,就相當(dāng)于異常的處理方式:

    1、使用try...catch...finally語句塊處理它。我們把這輛車可能出現(xiàn)的問題都考慮清楚了,并提供了備選方案(出現(xiàn)問題怎么做),如果沒有出現(xiàn)問題,那么用不到備選方案；如果出現(xiàn)了問題，根據(jù)問題去找對(duì)應(yīng)的備選方案，以保證車的正常運(yùn)行；如果出現(xiàn)了問題,但是又沒備選方案,那么車就跑不了;2、在函數(shù)簽名中使用throws 聲明交給函數(shù)調(diào)用者caller去解決。我知道車可能又問題，但是我不處理，誰來使用了，告訴調(diào)用者，這里可能有問題；那么調(diào)用者可以處理這個(gè)問題，也可以不處理；如果它不處理，還是會(huì)出現(xiàn)問題，如果處理了，肯定沒問題；A -》 B -》 C

Java采用的異常處理機(jī)制，是將異常處理的程序代碼集中在一起，與正常的程序代碼分開，使得程序簡(jiǎn)潔、優(yōu)雅，并易于維護(hù)。

 Java提供的是異常處理的抓拋模型。

Java程序的執(zhí)行過程中如出現(xiàn)異常，會(huì)生成一個(gè)異常類對(duì)象，該異常對(duì)象將被提交給Java運(yùn)行時(shí)系統(tǒng)，這個(gè)過程稱為拋出(throw)異常。

異常對(duì)象的生成:由虛擬機(jī)自動(dòng)生成：程序運(yùn)行過程中，虛擬機(jī)檢測(cè)到程序發(fā)生了問題，如果在當(dāng)前代碼中沒有找到相應(yīng)的處理程序，就會(huì)在后臺(tái)自動(dòng)創(chuàng)建一個(gè)對(duì)應(yīng)異常類的實(shí)例對(duì)象并拋出——自動(dòng)拋出。由開發(fā)人員手動(dòng)創(chuàng)建：Exception exception = new ClassCastException();創(chuàng)建好的異常對(duì)象不拋出對(duì)程序沒有任何影響，和創(chuàng)建一個(gè)普通對(duì)象一樣。

異常的拋出機(jī)制:
如果一個(gè)方法內(nèi)拋出異常，該異常對(duì)象會(huì)被拋給調(diào)用者方法中處理。如果異常沒有在調(diào)用者方法中處理，它繼續(xù)被拋給這個(gè)調(diào)用方法的上層方法。這個(gè)過程將一直繼續(xù)下去，直到異常被處理。這一過程稱為捕獲(catch)異常。
如果一個(gè)異?；氐絤ain()方法，并且main()也不處理，則程序運(yùn)行終止。
程序員通常只能處理Exception，而對(duì)Error無能為力。

異常處理機(jī)制一：try-catch-finally
語法格式：

        try{...... //可能產(chǎn)生異常的代碼}catch( ExceptionName1 e ){...... //當(dāng)產(chǎn)生ExceptionName1型異常時(shí)的處置措施}catch( ExceptionName2 e ){...... //當(dāng)產(chǎn)生ExceptionName2型異常時(shí)的處置措施}[ finally{...... //無論是否發(fā)生異常，都無條件執(zhí)行的語句} ]

語法解釋：
try：
捕獲異常的第一步是用try{…}語句塊選定捕獲異常的范圍，將可能出現(xiàn)異常的代碼放在try語句塊中。
如果發(fā)生異常，則嘗試去匹配catch塊，catch塊可以有多個(gè)（因?yàn)閠ry塊可以出現(xiàn)多個(gè)不同類型異常）;
如果執(zhí)行完try不管有沒有發(fā)生異常，則接著去執(zhí)行finally塊和finally后面的代碼（如果有的話）。

catch (Exceptiontype e)：
在catch語句塊中是對(duì)異常對(duì)象進(jìn)行處理的代碼。每個(gè)try語句塊可以伴隨一個(gè)或多個(gè)catch語句，用于處理可能產(chǎn)生的不同類型的異常對(duì)象。
每一個(gè)catch塊用于捕獲并處理一個(gè)特定的異常，或者這異常類型的子類。Java可以將多個(gè)異常聲明在一個(gè)catch中。 catch(Exception1 | Exception2 | Exception3 e)
catch后面的括號(hào)定義了異常類型和異常參數(shù)。如果異常與之匹配且是最先匹配到的，則虛擬機(jī)將使用這個(gè)catch塊來處理異常。
在catch塊中可以使用這個(gè)塊的異常參數(shù)來獲取異常的相關(guān)信息。異常參數(shù)是這個(gè)catch塊中的局部變量，其它塊不能訪問。與其它對(duì)象一樣，可以訪問一個(gè)異常對(duì)象的成員變量或調(diào)用它的方法。

	①、getMessage() 獲取異常信息，返回字符串。②、printStackTrace() 獲取異常類名和異常信息，以及異常出現(xiàn)在程序中的位置。返回值void。

如果當(dāng)前try塊中發(fā)生的異常在后續(xù)的所有catch中都沒捕獲到，則先去執(zhí)行finally，然后到這個(gè)函數(shù)的外部caller中去匹配異常處理器。
如果try中沒有發(fā)生異常，則所有的catch塊將被忽略。

注意：如果明確知道產(chǎn)生的是何種異常，
可以用該異常類作為catch的參數(shù)；
也可以用其父類作為catch的參數(shù)。比如：可以用 ArithmeticException 類作為參數(shù)的地方，
就可以用RuntimeException類作為參數(shù)，
或者用所有異常的父類Exception類作為參數(shù)。但不能是與ArithmeticException類無關(guān)的異常，如NullPointerException（catch中的語句將不會(huì)執(zhí)行）。

finally：
finally塊通常是可選的。捕獲異常的最后一步是通過finally語句為異常處理提供一個(gè)統(tǒng)一的出口，使得在控制流轉(zhuǎn)到程序的其它部分以前，能夠?qū)Τ绦虻臓顟B(tài)作統(tǒng)一的管理。
不論在try代碼塊中是否發(fā)生了異常事件，catch語句是否執(zhí)行，catch語句是否有異常，catch語句中是否有return，finally塊中的語句都會(huì)被執(zhí)行。
一個(gè)try至少要有一個(gè)catch塊，否則， 至少要有1個(gè)finally塊。但是finally不是用來處理異常的，finally不會(huì)捕獲異常。
finally主要做一些清理工作，如流的關(guān)閉，數(shù)據(jù)庫連接的關(guān)閉等。

public class Test_Input_01 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);/** 當(dāng)我們只寫一個(gè)try{}的時(shí)候,會(huì)報(bào)錯(cuò):* 	Syntax error, insert "Finally" to complete TryStatement* 	語法錯(cuò)誤，插入“Finally”來完成Try塊* * 總結(jié): try不能單獨(dú)存在,必須結(jié)合catch或finally來使用
* 	try塊中沒有異常,會(huì)執(zhí)行finally(如果有)*  try塊中有異常,會(huì)執(zhí)行對(duì)應(yīng)的catch塊(如果有),try中異常發(fā)生點(diǎn)之后的代碼將不會(huì)執(zhí)行*/try{//try塊中放可能發(fā)生異常的代碼。//如果執(zhí)行完try且不發(fā)生異常，則接著去執(zhí)行finally塊和finally后面的代碼（如果有的話）。//如果發(fā)生異常，則嘗試去匹配catch塊。異常點(diǎn)之后的代碼不會(huì)運(yùn)行//這行代碼有可能出錯(cuò)int num1 = sc.nextInt(); //這行代碼如果出現(xiàn)異常,那么后面的輸出語句就不執(zhí)行int num2 = sc.nextInt();System.out.println(num1+"\t"+num2);System.out.println(num1/num2);String str = null;System.out.println(str.charAt(0));}catch(InputMismatchException | NullPointerException e) { // catch(異常對(duì)象)	當(dāng)異常發(fā)生了,catch就會(huì)捕獲對(duì)應(yīng)的異常
// 每一個(gè)catch塊用于捕獲并處理一個(gè)特定的異常，或者這異常類型的子類。
//Java7中可以將多個(gè)異常聲明在一個(gè)catch中。
// catch(Exception1 | Exception2 | Exception3 e)
// catch后面的括號(hào)定義了異常類型和異常參數(shù)。
//如果異常與之匹配且是最先匹配到的，則虛擬機(jī)將使用這個(gè)catch塊來處理異常。// 在catch塊中可以使用這個(gè)塊的異常參數(shù)來獲取異常的相關(guān)信息。//異常參數(shù)是這個(gè)catch塊中的局部變量，其它塊不能訪問。// 如果當(dāng)前try塊中發(fā)生的異常在后續(xù)的所有catch中都沒捕獲到，//則先去執(zhí)行finally，然后到這個(gè)函數(shù)的外部caller中去匹配異常處理器。// 如果try中沒有發(fā)生異常，則所有的catch塊將被忽略。System.out.println("catch塊 - try里面發(fā)生了異常 - 空指針和輸入不匹配異常都走這個(gè)Catch");}catch(java.lang.ArithmeticException e){e.getMessage();System.out.println("算數(shù)異常:除數(shù)不能為0");}catch(Exception e){System.out.println("程序發(fā)生未知異常");}finally {// finally塊通常是可選的。// 無論異常是否發(fā)生，異常是否匹配被處理，finally都會(huì)執(zhí)行。// 一個(gè)try至少要有一個(gè)catch塊，否則， 至少要有1個(gè)finally塊。//但是finally不是用來處理異常的，finally不會(huì)捕獲異常。// finally主要做一些清理工作，如流的關(guān)閉，數(shù)據(jù)庫連接的關(guān)閉等。 System.out.println("finally塊");}System.out.println("異常捕獲之后的代碼");}
}	

需要注意的地方
1、try塊中的局部變量和catch塊中的局部變量（包括異常變量），以及finally中的局部變量，他們之間不可共享使用。

2、每一個(gè)catch塊用于處理一個(gè)異常。異常匹配是按照catch塊的順序從上往下尋找的，只有第一個(gè)匹配的catch會(huì)得到執(zhí)行。匹配時(shí)，不僅運(yùn)行精確匹配，也支持父類匹配，因此，如果同一個(gè)try塊下的多個(gè)catch異常類型有父子關(guān)系，應(yīng)該將子類異常放在前面，父類異常放在后面，這樣保證每個(gè)catch塊都有存在的意義。

3、java中，異常處理的任務(wù)就是將執(zhí)行控制流從異常發(fā)生的地方轉(zhuǎn)移到能夠處理這種異常的地方去。也就是說：當(dāng)一個(gè)函數(shù)的某條語句發(fā)生異常時(shí)，這條語句的后面的語句不會(huì)再執(zhí)行，它失去了焦點(diǎn)。執(zhí)行流跳轉(zhuǎn)到最近的匹配的異常處理catch代碼塊去執(zhí)行，異常被處理完后，執(zhí)行流會(huì)接著在“處理了這個(gè)異常的catch代碼塊”后面接著執(zhí)行。

有的編程語言當(dāng)異常被處理后，控制流會(huì)恢復(fù)到異常拋出點(diǎn)接著執(zhí)行，

這種策略叫做：resumption model of exception handling（恢復(fù)式異常處理模式）

而Java則是讓執(zhí)行流恢復(fù)到處理了異常的catch塊后接著執(zhí)行，
這種策略叫做：termination model of exception handling（終結(jié)式異常處理模式）

public static void main(String[] args){try {foo();}catch(ArithmeticException ae) {System.out.println("處理異常");}
}
public static void foo(){int a = 5/0;  //異常拋出點(diǎn)System.out.println("Look me!!!");  //不會(huì)執(zhí)行
}

finally塊不管異常是否發(fā)生，只要對(duì)應(yīng)的try執(zhí)行了，則它一定也執(zhí)行。

只有一種方法讓finally塊不執(zhí)行：System.exit()。

因此finally塊通常用來做資源釋放操作：關(guān)閉文件，關(guān)閉數(shù)據(jù)庫連接等等。

良好的編程習(xí)慣是：在try塊中打開資源，在finally塊中清理釋放這些資源。

需要注意的地方:

1、finally塊沒有處理異常的能力。處理異常的只能是catch塊。

2、在同一try…catch…finally塊中 ，如果try中拋出異常，且有匹配的catch塊，則先執(zhí)行catch塊，再執(zhí)行finally塊。如果沒有catch塊匹配，則先執(zhí)行finally，然后去外面的調(diào)用者中尋找合適的catch塊。

3、在同一try…catch…finally塊中 ，try發(fā)生異常，且匹配的catch塊中處理異常時(shí)也拋出異常，那么后面的finally也會(huì)執(zhí)行：首先執(zhí)行finally塊，然后去外圍調(diào)用者中尋找合適的catch塊。

這是正常的情況，但是也有特例。關(guān)于finally有很多惡心，偏、怪、難的問題.

具體在最后一節(jié):finally塊和return 講解

不捕獲異常時(shí)的情況：

前面使用的異常都是RuntimeException類或是它的子類，這些類的異常的特點(diǎn)是：即使沒有使用try和catch捕獲，Java自己也能捕獲，并且編譯通過( 但運(yùn)行時(shí)會(huì)發(fā)生異常使得程序運(yùn)行終止 )。

如果拋出的異常是IOException等類型的非運(yùn)行時(shí)異常，則必須捕獲，否則編譯錯(cuò)誤。也就是說，我們必須處理編譯時(shí)異常，將異常進(jìn)行捕捉，轉(zhuǎn)化為運(yùn)行時(shí)異常。

import java.io.*;public class IOExp {public static void main(String[] args) {try {FileInputStream in = new FileInputStream("hello.txt");int b;b = in.read();while (b != -1) {System.out.print((char) b);b = in.read();}in.close();} catch (IOException e) {System.out.println(e);} finally {System.out.println(" It’s ok!");}}
}

異常處理機(jī)制二：throws
throws是另一種處理異常的方式，它不同于try…catch…finally，throws僅僅是將函數(shù)中可能出現(xiàn)的異常向調(diào)用者聲明，而自己則不具體處理。

throws聲明：如果一個(gè)方法內(nèi)部的代碼會(huì)拋出檢查異常（checked exception），而方法自己又沒有完全處理掉或并不能確定如何處理這種異常，則javac保證你必須在方法的簽名上使用throws關(guān)鍵字聲明這些可能拋出的異常，表明該方法將不對(duì)這些異常進(jìn)行處理，而由該方法的調(diào)用者負(fù)責(zé)處理，否則編譯不通過。

在方法聲明中用throws語句可以聲明拋出異常的列表，throws后面的異常類型可以是方法中產(chǎn)生的異常類型，也可以是它的父類。

采取這種異常處理的原因可能是：方法本身不知道如何處理這樣的異常，或者說讓調(diào)用者處理更好，調(diào)用者需要為可能發(fā)生的異常負(fù)責(zé)。

語法格式：

修飾符 返回值類型 方法名() throws ExceptionType1 , ExceptionType2 ,ExceptionTypeN{

//方法內(nèi)部可以拋出 ExceptionType1 , ExceptionType2 ,ExceptionTypeN 類的異常，或者他
們的子類的異常對(duì)象。

}

import java.io.*;public class ThrowsTest {public static void main(String[] args) {ThrowsTest t = new ThrowsTest();try {t.readFile();} catch (IOException e) {e.printStackTrace();}}public void readFile() throws IOException {FileInputStream in = new FileInputStream("hello.txt");int b;b = in.read();while (b != -1) {System.out.print((char) b);b = in.read();}in.close();}
}

4.4手動(dòng)拋出異常：throw

Java異常類對(duì)象除在程序執(zhí)行過程中出現(xiàn)異常時(shí)由系統(tǒng)自動(dòng)生成并拋出，也可根據(jù)需要使用人工創(chuàng)建并拋出。

首先要生成異常類對(duì)象，然后通過throw語句實(shí)現(xiàn)拋出操作(提交給Java運(yùn)行環(huán)境)。
throw exceptionObject

程序員也可以通過throw語句手動(dòng)顯式的拋出一個(gè)異常。throw語句的后面可以拋出的異常必須是Throwable或其子類的實(shí)例。下面的語句在編譯時(shí)將會(huì)產(chǎn)生語法錯(cuò)誤：

throw new String(“你拋我試試.”);

throw 語句必須寫在函數(shù)中，執(zhí)行throw 語句的地方就是一個(gè)異常拋出點(diǎn)，它和由JRE自動(dòng)形成的異常拋出點(diǎn)沒有任何差別。

public class StudentTest {public static void main(String[] args) {try {Student s = new Student();s.regist(-1001);System.out.println(s);} catch (Exception e) {System.out.println(e.getMessage());}}
}class Student {private int id;public void regist(int id) throws Exception {if (id > 0) {this.id = id;} else {// System.out.println("您輸入的數(shù)據(jù)非法！");//手動(dòng)拋出異常對(duì)象// throw new RuntimeException("您輸入的數(shù)據(jù)非法！");throw new Exception("您輸入的數(shù)據(jù)非法！");//錯(cuò)誤的// throw new String("不能輸入負(fù)數(shù)");}}@Overridepublic String toString() {return "Student [id=" + id + "]";}
}

throws和throw的區(qū)別:

throw是語句拋出一個(gè)異常。
語法：throw (異常對(duì)象);
throw e;

throws是方法可能拋出異常的聲明。(用在聲明方法時(shí)，表示該方法可能要拋出異常)
語法：(修飾符)(方法名)([參數(shù)列表])[throws(異常類)]{…}
public void doA(int a) throws Exception1,Exception3{…}

throw語句用在方法體內(nèi)，表示拋出異常，由方法體內(nèi)的語句處理。
throws出現(xiàn)在方法函數(shù)頭，表示在拋出異常，由該方法的調(diào)用者來處理。

throws主要是聲明這個(gè)方法會(huì)拋出這種類型的異常，使它的調(diào)用者知道要捕獲這個(gè)異常。

 throw是具體向外拋異常的動(dòng)作，所以它是拋出一個(gè)異常實(shí)例。throws說明你有那個(gè)可能，傾向。

throw的話，那就是你把那個(gè)傾向變成真實(shí)的了。
兩者都是消極處理異常的方式（這里的消極并不是說這種方式不好），只是拋出或者可能拋出異常，但是不會(huì)由函數(shù)去處理異常，真正的處理異常由函數(shù)的上層調(diào)用處理。

原文鏈接：鏈接描述

5.理解OOP面向?qū)ο?/h3>

面向?qū)ο笥心男┨匦?#xff1f;
封裝，繼承，多態(tài)

1、封裝就是將類的信息隱藏在類內(nèi)部，不允許外部程序直接訪問，而是通過該類的方法實(shí)現(xiàn)對(duì)隱藏信息的操作和訪問。 良好的封裝能夠減少耦合。

2、繼承是從已有的類中派生出新的類，新的類繼承父類的屬性和行為，并能擴(kuò)展新的能力，大大增加程序的重用性和易維護(hù)性。在Java中是單繼承的，也就是說一個(gè)子類只有一個(gè)父類。

3、多態(tài)是同一個(gè)行為具有多個(gè)不同表現(xiàn)形式的能力。在不修改程序代碼的情況下改變程序運(yùn)行時(shí)綁定的代碼。實(shí)現(xiàn)多態(tài)的三要素：繼承、重寫、父類引用指向子類對(duì)象。

靜態(tài)多態(tài)性：通過重載實(shí)現(xiàn)，相同的方法有不同的參數(shù)列表，可以根據(jù)參數(shù)的不同，做出不同的處理。
動(dòng)態(tài)多態(tài)性：在子類中重寫父類的方法。運(yùn)行期間判斷所引用對(duì)象的實(shí)際類型，根據(jù)其實(shí)際類型調(diào)用相應(yīng)的方法。

6.Java的特點(diǎn)

Java是一門面向?qū)ο蟮木幊陶Z言。

Java具有平臺(tái)獨(dú)立性和移植性。

Java有一句口號(hào)：Write once, run anywhere，一次編寫、到處運(yùn)行。這也是Java的魅力所在。而實(shí)現(xiàn)這種特性的正是Java虛擬機(jī)JVM。已編譯的Java程序可以在任何帶有JVM的平臺(tái)上運(yùn)行。你可以在windows平臺(tái)編寫代碼，然后拿到linux上運(yùn)行。只要你在編寫完代碼后，將代碼編譯成.class文件，再把class文件打成Java包，這個(gè)jar包就可以在不同的平臺(tái)上運(yùn)行了。
Java具有穩(wěn)健性。

Java是一個(gè)強(qiáng)類型語言，它允許擴(kuò)展編譯時(shí)檢查潛在類型不匹配問題的功能。Java要求顯式的方法聲明，它不支持C風(fēng)格的隱式聲明。這些嚴(yán)格的要求保證編譯程序能捕捉調(diào)用錯(cuò)誤，這就導(dǎo)致更可靠的程序。

異常處理是Java中使得程序更穩(wěn)健的另一個(gè)特征。異常是某種類似于錯(cuò)誤的異常條件出現(xiàn)的信號(hào)。使用try/catch/finally語句，程序員可以找到出錯(cuò)的處理代碼，這就簡(jiǎn)化了出錯(cuò)處理和恢復(fù)的任務(wù)。

Java是如何實(shí)現(xiàn)跨平臺(tái)的？

Java是通過JVM（Java虛擬機(jī)）實(shí)現(xiàn)跨平臺(tái)的。

JVM可以理解成一個(gè)軟件，不同的平臺(tái)有不同的版本。我們編寫的Java代碼，編譯后會(huì)生成.class 文件（字節(jié)碼文件）。Java虛擬機(jī)就是負(fù)責(zé)將字節(jié)碼文件翻譯成特定平臺(tái)下的機(jī)器碼，通過JVM翻譯成機(jī)器碼之后才能運(yùn)行。不同平臺(tái)下編譯生成的字節(jié)碼是一樣的，但是由JVM翻譯成的機(jī)器碼卻不一樣。

只要在不同平臺(tái)上安裝對(duì)應(yīng)的JVM，就可以運(yùn)行字節(jié)碼文件，運(yùn)行我們編寫的Java程序。

因此，運(yùn)行Java程序必須有JVM的支持，因?yàn)榫幾g的結(jié)果不是機(jī)器碼，必須要經(jīng)過JVM的翻譯才能執(zhí)行。

Java 與 C++ 的區(qū)別

Java 是純粹的面向?qū)ο笳Z言，所有的對(duì)象都繼承自 java.lang.Object，
C++ 兼容 C ，不但支持面向?qū)ο笠仓С置嫦蜻^程。Java 通過虛擬機(jī)從而實(shí)現(xiàn)跨平臺(tái)特性， C++ 依賴于特定的平臺(tái)。Java 沒有指針，它的引用可以理解為安全指針，而 C++ 具有和 C 一樣的指針。Java 支持自動(dòng)垃圾回收，而 C++ 需要手動(dòng)回收。Java 不支持多重繼承，只能通過實(shí)現(xiàn)多個(gè)接口來達(dá)到相同目的，而 C++ 支持多重繼承。

7.JDK/JRE/JVM三者的關(guān)系

JVM

英文名稱（Java Virtual Machine），就是我們耳熟能詳?shù)?Java 虛擬機(jī)。Java 能夠跨平臺(tái)運(yùn)行的核心在于 JVM 。

所有的java程序會(huì)首先被編譯為.class的類文件，這種類文件可以在虛擬機(jī)上執(zhí)行。也就是說class文件并不直接與機(jī)器的操作系統(tǒng)交互，而是經(jīng)過虛擬機(jī)間接與操作系統(tǒng)交互，由虛擬機(jī)將程序解釋給本地系統(tǒng)執(zhí)行。

針對(duì)不同的系統(tǒng)有不同的 jvm 實(shí)現(xiàn)，有 Linux 版本的 jvm 實(shí)現(xiàn)，也有Windows 版本的 jvm 實(shí)現(xiàn)，但是同一段代碼在編譯后的字節(jié)碼是一樣的。這就是Java能夠跨平臺(tái)，實(shí)現(xiàn)一次編寫，多處運(yùn)行的原因所在。

JRE

英文名稱（Java Runtime Environment），就是Java 運(yùn)行時(shí)環(huán)境。我們編寫的Java程序必須要在JRE才能運(yùn)行。它主要包含兩個(gè)部分，JVM 和 Java 核心類庫。

JRE是Java的運(yùn)行環(huán)境，并不是一個(gè)開發(fā)環(huán)境，所以沒有包含任何開發(fā)工具，如編譯器和調(diào)試器等。

如果你只是想運(yùn)行Java程序，而不是開發(fā)Java程序的話，那么你只需要安裝JRE即可。

JDK

英文名稱（Java Development Kit），就是 Java 開發(fā)工具包

學(xué)過Java的同學(xué)，都應(yīng)該安裝過JDK。當(dāng)我們安裝完JDK之后，目錄結(jié)構(gòu)是這樣的

可以看到，JDK目錄下有個(gè)JRE，也就是JDK中已經(jīng)集成了 JRE，不用單獨(dú)安裝JRE。

另外，JDK中還有一些好用的工具，如jinfo，jps，jstack等。

最后，總結(jié)一下JDK/JRE/JVM，他們?nèi)叩年P(guān)系

JRE = JVM + Java 核心類庫JDK = JRE + Java工具 + 編譯器 + 調(diào)試器

8.面向?qū)ο蠛兔嫦蜻^程的區(qū)別？

面向?qū)ο蠛兔嫦蜻^程是一種軟件開發(fā)思想。

面向過程就是分析出解決問題所需要的步驟，然后用函數(shù)按這些步驟實(shí)現(xiàn)，使用的時(shí)候依次調(diào)用就可以了。

面向?qū)ο?/strong>是把構(gòu)成問題事務(wù)分解成各個(gè)對(duì)象，分別設(shè)計(jì)這些對(duì)象，然后將他們組裝成有完整功能的系統(tǒng)。

byte，8bit
char，16bit
short，16bit
int，32bit
float，32bit
long，64bit
double，64bit
boolean，只有兩個(gè)值：true、false，可以使?用 1 bit 來存儲(chǔ)

建議使用BigDecimal或者Long來表示金額。