Eg：

public class Test2 {

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

…

System.out.print("請輸入除數:");

int num2 = 0;

if (in.hasNextInt()) { // 如果輸入的除數是整數

num2 = in.nextInt();

if (0 == num2) { // 如果輸入的除數是0

System.err.println("輸入的除數是0，程序退出。");

System.exit(1);

}

} else { // 如果輸入的除數不是整數

System.err.println("輸入的除數不是整數，程序退出。");

System.exit(1);

}

…

}

}

弊端：

1、代碼臃腫

2、程序員要花很大精力“堵漏洞”

3、程序員很難堵住所有“漏洞”

java中用2種方法處理異常：

1、在發生異常的地方直接處理；

2、將異常拋給調用者，讓調用者處理。

給代碼添加異常處理：(alt+shift+z)

選擇要處理的代碼——右鍵：Surround with——try/catch Block

Java編程語言使用異常處理機制為程序提供了錯誤處理的能力；

Java的異常處理是通過5個關鍵字來實現的：try、catch、 finally、throw、throws

★第一種情況 ：正常

★第三種情況：異常類型不匹配；

★第二種情況：出現異常：

　　異常是一種特殊的對象，類型為java.lang.Exception或其子類；

printStackTrace的堆棧跟蹤功能顯示出程序運行到當前類的執行流程；

在catch塊中處理異常：

　　1、加入用戶自定義處理信息

　　　　System.err.println("出現錯誤：被除數和除數必須是整數，” +"除數不能為零。");

2、調用方法輸出異常信息(獲得異常的內存堆棧信息及錯誤的位置)：e. printStackTrace（）；

獲得異常信息：e.getMessages（）；

　　　　　　異常對象常用的方法：

異 常 類 型

說 明

Exception

異常層次結構的父類

ArithmeticException

算術錯誤情形，如以零作除數

ArrayIndexOutOfBoundsException

數組下標越界

NullPointerException

嘗試訪問 null 對象成員

ClassNotFoundException

不能加載所需的類

IllegalArgumentException

方法接收到非法參數

InputMismatchException

欲得到的數據類型與實際輸入的類型不匹配

ClassCastException

對象強制類型轉換出錯

NumberFormatException

數字格式轉換異常，如把"abc"轉換成數字

頂層是java.lang.Throwable類，檢查性異常、運行期異常、錯誤都是這個類的子孫類，java.lang.Exception和java.lang.Error繼承自java.lang.Throwable，而java.lang.RuntimeException繼承自java.lang.Exception

異常分類：

1、檢查性異常(Checked異常:必須捕獲或聲明為拋出)：java.lang.Exception

程序正確，但因為外在的環境條件不滿足引發。例如：用戶錯誤及I/O問題--程序試圖打開一個並不存在的遠程Socket端口，或者是打開不存在的文件時。這不是程序本身的邏輯錯誤，而很可能是遠程機器名字錯誤(用戶拼寫錯誤)，對商用軟件系統，程序開發者必須考慮並處理這個問題。java編譯器強制要求處理這類異常，如果不捕獲這類異常，程序將不能被編譯。

2、運行期異常（不要求必須捕獲或聲明拋出）：java.lang.RuntimeException這意味著程序存在bug，如數組越界、0被除、入參不滿足規範...這類異常需要更改程序來避免，java編譯器強制要求處理這類異常。

3、錯誤：java.lang.Error

一般很少見，也很難通過程序解決，它可能源於程序的bug，但一般更可能源於環境問題，如內存耗盡。錯誤在程序中無需處理，而由運行環境處理。

●不執行的一種情況：

★存在return的try-catch-finally塊：

●多重catch塊：多重catch塊的排序順序必須是從子類到父類，最後一個一般都是Exception；

　　引發多種類型的異常

　　　排列catch 語句的順序：先子類後父類

　　　發生異常時按順序逐個匹配

　　　只執行第一個與異常類型匹配的catch語句

如果把finally塊置try...catch...語句後，finally塊一般都會得到執行，它相當於一個萬能的保險，即使前面的try塊發生異常，而又沒有對應異常的catch塊，finally塊將馬上執行。

以下情形，finally塊將不會被執行：

　　1、finally塊中發生了異常；

　　2、程序所在的線程死亡；

　　3、在前面的代碼中用了System.exit()；//中斷程序，退出Java虛擬機

　　4、關閉CPU

//異常示例

import java.io.*;

import java.net.*;

public class Demo148 {

public static void main(String[] args) {

FileReader fr=null;

//檢查異常

//1、打開不存在的文件

//FileReader fr=new FileReader("d:\\aa.txt");

try { //使用try{}catch(Exception e){}將可能出錯的程序放入到裏面，當出錯時會有相應提示，便於解決bug

//在出現異常的地方就終止執行代碼，然後直接進入到catch語句

//如裏有多個catch語句，則進入匹配異常的catch語句輸入出信息

fr=new FileReader("d:\\aa.txt");

//System.exit(-1); //使用System.exit()後finally語句塊不再執行

Socket s=new Socket("192.168.1.1",21);

} catch (FileNotFoundException e) {//catch(Exception e)捕獲所有錯誤信息，為了方便一般使用此方法來捕獲所有錯誤信息

// 把異常的信息輸出，利於排除bug

//e.getMessage();

System.out.println("文件不存在："+e.getMessage());//.getMessage()不如.printStackTrace()

//e.printStackTrace(); //輸出bug信息

//處理

} catch (IOException e2){//UnknownHostException

e2.printStackTrace();

} finally {

//try..catch..語句塊中不管出沒出現異常，一般都會執行finally語句塊

//一般說，把需要關閉的資源。如[文件]、[鏈接]、[內存]...

System.out.println("測試進入finally語句塊");

if(fr!=null){

try {

fr.close();

} catch (Exception e) {

e.printStackTrace();

}

}

}

System.out.println("OK1");

聲明異常：throws

拋出異常：throw

throws：使用：

eg1：由調用者處理異常：

Eg2：由調用者繼續聲明異常：

throw的使用：性別是由調用者處理異常：在main方法中不加try處理會報錯；

測試類：

結果：

異常的分類：

多個異常的處理規則：

●定義多個catch可精確地定位異常。如果為子類的異常定義了特殊的catch塊，而父類的異常則放在另外一個catch塊中，此時，必需滿足以下規則：

●子類異常的處理塊必需在父類異常處理塊的前面，否則會發生編譯錯誤。所以越特殊的異常越在前面處理，越普通的異常越在後面處理。這類似於制訂防火墻的規則次序：較特殊的規則在前，較普通的規則在後。

throws和throw的區別：

　　1、作用不同：throw用於在程序中拋出異常，throws用於生命在該方法內拋出了異常；

　　2、使用的位置不同：throw位於方法體內部，可以作為單獨語句使用；

　　　　　　 throws必須跟在方法參數列表的後面不能單獨使用；

　　3、內容不同：throw拋出一個異常對象，而且只能是一個；

　　　　　　 throws後面可以跟多個異常類；

日誌（log）：

主要用來記錄系統運行中一些重要操作信息

便於監視系統運行情況，幫助用戶提前發現和避開可能出現的問題，或者出現問題後根據日誌找到原因

日誌分類：

SQL日誌：記錄系統執行的SQL語句；

異常日誌：記錄系統運行中發生的異常事件；

業務日誌：記錄系統運行過程，如用戶登陸，操作記錄；

log4j是一個非常優秀的開源日誌記錄工具

控制日誌的輸出級別

控制日誌信息輸送的目的地是控制臺、文件等

控制每一條日誌的輸出格式

使用log4j記錄日誌步驟：

★在項目中加入log4j所使用的JAR文件；（導入架包：項目（右擊）—文件（properties）———）

★創建log4j.properties文件（項目（右擊）—新建（new）—文件（File）—輸入文件名）；

★編寫log4j.properties文件，配置日誌信息（文件上右鍵：編寫日誌，亂碼問題見筆記下面）；

★在程序中使用log4j記錄日誌信息（在文件中使用）；

Log4j配置文件：

1、輸出級別：日誌記錄器輸出級別：fatal > error > warn > info >debug

　　　　log4j.rootLogger=debug, stdout,logfile

　　●debug指的是日誌記錄器（Logger）的輸出級別，主要輸出級別及含義如下：

　　　　◆fatal：指出嚴重的錯誤事件將會導致應用程序的退出；

　　　　 ◆error：指出雖然發生錯誤事件，但仍不會影響系統的繼續運行；

　　　　 ◆warn：表明會出現潛在的錯誤的形式；

　　　　 ◆info：在粗粒程度級別上指明消息，強調應用程序的運行過程；

　　　　 ◆debuj：指出細粒度信息事件，對調試應用程序時非常有幫助的；

　　　　▲日誌記錄器各個級別輸出級別：fatal > error > warn > info >debug

2、日誌輸出的目的地Appender：

log4j.rootLogger=debug, stdout,logfile

●stdout,logfile指的是日誌輸出目的地的名字；

log4j允許記錄日誌到多個輸出目的地，一個輸出目的地被稱為一個Adooender。

　　log4j中最常用的Appender有以下兩種：

　　　　 ◆ConsoleAppender：輸出日誌事件到控制臺。通過Target屬性配置輸出到System.out或System.err，默認的目標是System.out；

　　　　 Eg：log4j.appender.stdout=org.apache.log4j.ConsoleAppender；//日誌信息輸出到控制臺

　　log4j.appender.stdout.Target=System.err；//信息打印到System.err上

　　　　 ◆FileAppender：輸出日誌到一個文件，

　　 Eg：log4j.appender.logfile=org.apache.log4j.FileAppender；//日誌信息寫到文件中

3、日誌布局類型Layout：

log4j.appender.logfile.layout=org.apache.log4j.PatternLayout

　　●Appenderb必須使用一個與之相關聯的布局類型Layout，用來指定它的輸出樣式。

　　Log4j中最常用的Layout有以下三種：

　　　　◆HTMLLayout：格式化日誌輸出為HTML表格

　　　　◆SimpleLayout：以一種非常簡單的方式格式化日誌輸出，它輸出級別Level，然後跟著一個破折號“——”，最後是日誌信息。

　　　　◆PatternLayout：根據指定的轉換模式格式化日誌輸出，從而支持豐富多樣的輸出格式。需要配置layout.ConversionPattern屬性，若沒有配置該屬性，則使用默認的轉換模式

4、轉換模式ConversionPattern：

　　log4j.appender.logfile.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %l %F %p %m%n

　　●對於PatternLayout，需要配置layout.Conversionpattern屬性，常用的配置參數及含義如下：

　　　　◆%d：用來設置輸出日誌的日期和時間，默認格式為ISO8601。也可以在其後指定格式。

　　　　　　比如：%d{yyyy-MM-dd HH:mm:ss}，輸出格式類似於2016-03-09 17:51:08

　　　　◆%m：用來輸出代碼中指定的消息。

　　　　◆%n：用來輸出一個回車換行符

　　　　◆%I:用來輸出日誌時間的發生位置，包括類名、發生的線程，以及在代碼中的行數。

　　　　　　例如：如果輸出位cn.jbit.log.Test11.main(Test11.java:21)，則說明日誌事件發生在cn.jbit.log包下的Test11類的main線程中，在代碼中的行數為第21行。

　　　　◆%p：用來輸出優先級，及debug、info、warn、error、fatal等。

　　　　◆%F：用來輸出文件名

　　　　◆%M：用來輸出方法名

Eg：

### 設置Logger輸出級別和輸出目的地 ###

log4j.rootLogger=debug, stdout,logfile //目的地的名字和目的地的名字

### 把日誌信息輸出到控制臺 ###

log4j.appender.stdout=org.apache.log4j.ConsoleAppender //日誌信息輸出到控制臺

log4j.appender.stdout.Target=System.err //信息打印到System.err上

log4j.appender.stdout.layout=org.apache.log4j.SimpleLayout //指定日誌布局類型

### 把日誌信息輸出到文件：jbit.log ###

log4j.appender.logfile=org.apache.log4j.FileAppender //日誌信息寫到文件中

log4j.appender.logfile.File=jbit.log //指定日誌輸出的文件名

log4j.appender.logfile.layout=org.apache.log4j.PatternLayout //指定轉換模式

log4j.appender.logfile.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %l %F %p %m%n //指定日誌布局類型

●解決文件亂碼的問題：

1、properties 文件中文亂碼問題 ：鼠標“右擊”文件 => Resource => Text file encoding => UTF-8 ；

2、properties 文件解析中文亂碼問題
　　Properties pps = new Properties();
　　pps.load(new InputStreamReader(TestProperty.class.getClassLoader().getResourceAsStream(“properties”), “UTF-8”));
3、log4j解析properties 中文亂碼問題
　　Logger logger = Logger.getLogger(“test-log”);
　　Properties pps = new Properties();
　　pps.load(new InputStreamReader(MvneLog.class.getClassLoader().getResourceAsStream(“log4j.properties”), “UTF-8”));
　　PropertyConfigurator.configure(pps);

自己也可以定義並拋出異常，方法2步：

●創建異常，拋出異常(首先實例化一個異常對象，然後用throw拋出)合在一起就是---throw new IOException("異常說明信息")，將創建異常，拋出異常合在一起的好處是：創建異常時，會包含異常創建處的行信息，異常被捕獲時可以通過堆棧跡(Stack Trace)的形式報告這些信息。如果在同一行代碼創建和拋出異常時，對於程序的調試將非常有用。所以，throw new XXX()已經成為一個標準的異常拋出範式。

●在定義一個方法時，方法塊中調用的方法可能會拋出異常，可用上面的throw new XXX()處理，如果不處理，那麽必需在方法定義時，用throws聲明這個方法全拋出的異常。

對異常的處理，有一條行之有效的默認規則：

向上拋出----被調用類在運行過程中對遇到的異常一概不作處理，而是直接向上拋出，一直到最上層的調用類，調用類根據應用系統的需求和特定的異常處理規則進行處理，如向控制臺輸出異常堆棧信息，打印在日誌文件中。用一句形象的話來說，就是誰使用，誰(最上層的調用類)處理。

●一個try語句塊後面可以寫多個catch語句塊，分別處理不同的異常。但排列順序必須是從子類到父類，最後一個一般都是Exception類。

●Java的Exception分兩大類運行時異常和非運行時異常(編譯異常)：

◆運行時異常：

★Java的非檢查異常(編譯器不要求強制處置的異常)：包括運行時異常（RuntimeException與其子類）和錯誤（Error）。Java編譯器不要求你一定要把它捕獲或者一定要繼續拋出，

▲運行時異常：運行時異常都是RuntimeException類及其子類異常：

■NullPointerException(空指針異常)

■ArrayIndexOutOfBoundsException（數組下標越界異常)

■ClassCastException（對象強制類型轉換出錯）

■ArithmeticException（算術錯誤）

　　　　　　　　　 ■NumberFormatException（數字格式轉換異常）

■java.lang.ArithmeticException類是RuntimeException的子類，當出現異常的運算條件時，將會拋出java.lang.ArithmeticException異常。

　　　　●這些異常是不檢查異常，程序中可以選擇捕獲處理，也可以不處理。這些異常一般是由程序邏輯錯誤引起的，程序應該從邏輯角度盡可能避免這類異常的發生。運行時異常的特點是Java編譯器不會檢查它，也就是說，當程序中可能出現這類異常，即使沒有用try-catch語句捕獲它，也沒有用throws子句聲明拋出它，也會編譯通過。

　　◆非運行時異常 （編譯異常）：是RuntimeException以外的異常，類型上都屬於Exception類及其子類。從程序語法角度講是必須進行處理的異常，如果不處理，程序就不能編譯通過（對checked exception(檢查異常)要求你必須要在方法裏面或者捕獲或者繼續拋出。）。如IOException、SQLException 、ClassNotFoundException等以及用戶自定義的Exception異常，一般情況下不自定義檢查異常；

●NullPointerException：當應用程序試圖在需要對象的地方使用 null 時，拋出該異常。

　　●這種情況包括：調用 null 對象的實例方法。

　　　　訪問或修改 null 對象的字段。

　　　　將 null 作為一個數組，獲得其長度。

　　　　將 null 作為一個數組，訪問或修改其時間片。

　　　　將 null 作為 Throwable 值拋出。

●邏輯錯誤：是指代碼邏輯問題

　　語法錯誤：是指代碼的通用性不規範

　　內部錯誤：是指程序中錯誤，所以只能通過代碼內部調試處理

　　運行時錯誤：是通過異常處理模型來完成

●Java中可能出現運行異常的代碼最佳的處理時期就是在編譯的時候處理並且捕獲。

●提供兩種異常處理機制：捕獲異常和聲明拋棄異常：

　　1）捕獲異常：在Java程序運行過程中系統得到一個異常對象是，它將會沿著方法的調用棧逐層回溯，尋找處理這一異常的代碼。找到能夠處理這種類型異常的方法後，運行時系統把當前異常交給這個方法處理；如果找不到可以捕獲異常的方法，則運行時系統將終止，相應的Java程序也將退出。捕獲異常是通過try-catch-finally語句實現的。

　　2）聲明拋棄異常：當Java程序運行時系統得到一個異常對象時，如果一個方法並不知道如何處理所出現的異常，則可在方法聲明時，聲明拋棄異常。聲明拋棄異常是在一個方法聲明中的throws子句中指明的。

●自定義異常可以繼承Exception或Throwable 類；

　　Java中，所有的異常都有一個共同的祖先 Throwable。

　　Throwable 指定代碼中可用異常傳播機制通過 Java 應用程序傳輸的任何問題的共性。

　　它有兩個重要的子類：Exception（異常）和 Error（錯誤），

　　二者都是 Java 異常處理的重要子類，各自都包含大量子類。

●Java異常的基類為java.lang.Throwable，java.lang.Error和java.lang.Exception繼承 Throwable，RuntimeException和其它的Exception等繼承Exception，具體的RuntimeException繼承RuntimeException。

　　◆擴展：錯誤和異常的區別(Error vs Exception)

　　　　1) java.lang.Error: Throwable的子類，用於標記嚴重錯誤。合理的應用程序不應該去try/catch這種錯誤。絕大多數的錯誤都是非正常的，就根本不該出現的。

　　　　　　java.lang.Exception: Throwable的子類，用於指示一種合理的程序想去catch的條件。即它僅僅是一種程序運行條件，而非嚴重錯誤，並且鼓勵用戶程序去catch它。

　　　　2) Error和RuntimeException 及其子類都是未檢查的異常（unchecked exceptions），而所有其他的Exception類都是檢查了的異常（checked exceptions）.

　　　　　　★checked exceptions: 通常是從一個可以恢復的程序中拋出來的，並且最好能夠從這種異常中使用程序恢復。

　　　　　　　　比如FileNotFoundException, ParseException等。檢查了的異常發生在編譯階段，必須要使用try…catch（或者throws）否則編譯不通過。

　　　　　　★unchecked exceptions: 通常是如果一切正常的話本不該發生的異常，但是的確發生了。發生在運行期，具有不確定性，主要是由於程序的邏輯問題所引起的。

　　　　　　　　比如ArrayIndexOutOfBoundException, ClassCastException等。從語言本身的角度講，程序不該去catch這類異常，雖然能夠從諸如RuntimeException這樣的異常中catch並恢復，但是並不鼓勵終端程序員這麽做，因為完全沒要必要。因為這類錯誤本身就是bug，應該被修復，出現此類錯誤時程序就應該立即停止執行。 因此，面對Errors和unchecked exceptions應該讓程序自動終止執行，程序員不該做諸如try/catch這樣的事情，而是應該查明原因，修改代碼邏輯。

　　　　　　★RuntimeException：RuntimeException體系包括錯誤的類型轉換、數組越界訪問和試圖訪問空指針等等。處理RuntimeException的原則是：如果出現 RuntimeException，那麽一定是程序員的錯誤。

　　　　　　　　例如，可以通過檢查數組下標和數組邊界來避免數組越界訪問異常。其他（IOException 是文件讀取流異常等等）checked異常一般是外部錯誤，例如試圖從文件尾後讀取數據等，這並不是程序本身的錯誤，而是在應用環境中出現的外部錯誤

●Java中，異常指不期而至的各種狀況，如：文件找不到、網絡連接失敗、非法參數等。

異常是一個事件，它發生在程序運行期間，幹擾了正常的指令流程。Java通 過API中Throwable類的眾多子類描述各種不同的異常。

●異常類有很多分類，父類是Exception.

　　子類：數組越界（ArrayIndexOutOfBoundsException）

　　　　 空指針異常（NullPointerExceptoin），

　　　　（ArthmeticException）算術異常，如零作除數，

　　　　（ClassNotFoundException）不能加載所需的類，

　　　　（ClassCastException）對象強制轉換出錯 ，

　　這些都是特定情況下出現的異常。當有多個catch時，前面的catch的異常是子異常，最後一般是異常的父類exception，出現什麽異常執行對應異常塊，沒有匹配的異常，執行父類異常塊。

●Java的try-catch-finally語句中，關鍵詞try後的一對大括號將一塊可能發生異常的代碼包起來，稱為監控區域。

　　Java方法在運行過程中出現異常，則創建異常對象。將異常拋出監控區域之外，由Java運行時系統試圖尋找匹配的catch子句以捕獲異常。

　　若有匹配的catch子句，則運行其異常處理代碼，try-catch語句結束。

　　如果try塊中代碼量太多，過於龐大，會提高程序的復雜度。如果程序發生異常，排查錯誤，分析問題代碼會需要較長的時間；

●Java中，Throwable類的printStackTrace()方法可以將此 throwable 及其追蹤輸出到指定的 PrintWriter。

●Java中，執行try-catch-finally語句需要註意：

　　第一：return語句並不是函數的最終出口，如果有finally語句，這在return之後還會執行finally（return的值會暫存在棧裏面，等待finally執行後再返回）

　　第二：finally裏面不建議放return語句，根據需要，return語句可以放在try和catch裏面和函數的最後。可行的做法有四種：

　 　　　1）return語句只在方法最後出現一次。

　　 　　 2）return語句僅在try和catch裏面都出現。

　　 　　3）return語句僅在try和方法最後都出現。

　　　　 4）return語句僅在catch和方法的最後都出現。

　　註意，除此之外的其他做法都是不可行的，編譯器會報錯。

　　（1）如果程序運行到try成功時可以返回結果，則采用方法2。

　　（2）如果程序運行到catch時（即中途出錯時）無需再繼續執行後面的代碼了，則采取方法4。

　　（3）如果程序運行到try或catch時還需要繼續執行後面的代碼，則采取方法1

●Java的異常處理機制中，throws語句用在方法定義時聲明該方法要拋出的異常類型，

　　如果拋出的是Exception異常類型，則該方法被聲明為拋出所有的異常。多個異常可使用逗號分割。使用throws關鍵字將異常拋給調用者後，調用者必須將throws聲明有異常的方法放置在try-catch語句中調用，在catch塊中要指定拋出的異常類或其父類，以便捕捉程序中可能出現的這種類型的異常，並處理。

　　如果調用者不想處理該異常，可以繼續向上拋出，但最終要有能夠處理該異常的調用者。

●Java的異常處理機制中，throws語句用在方法定義時聲明該方法要拋出的異常類型，

　　如果拋出的是Exception異常類型，則該方法被聲明為拋出所有的異常。多個異常可使用逗號分割。

　　使用throws關鍵字將異常拋給調用者後，調用者必須將throws聲明有異常的方法放置在try-catch語句中調用，在catch塊中要指定拋出的異常類或其父類，以便捕捉程序中可能出現的這種類型的異常，並處理。

　　如果調用者不想處理該異常，可以繼續向上拋出，但最終要有能夠處理該異常的調用者。

●Try是正常執行代碼，catch是try中代碼塊出現異常時被執行的代碼，finally是代碼正常執行後或異常執行後都要去執行的代碼塊，try-catch-finally結構中try是必須的，catch和finally均為可選，但兩者至少要出現一個。

●一個try語句塊後面可以寫多個catch語句塊，分別處理不同的異常。但排列順序必須是從子類到父類，最後一個一般都是Exception類。

●eg:

分析：在靜態方法main()中，類的非靜態成員方法不能直接調用，必須先創建對象，再使用對象名訪問。正確答案是A。

●Java異常分為check Exception還是uncheck Exception。

　　uncheck exception表明調用方無需捕獲處理該異常，一般是與運行時無法的錯誤，可能是調用方傳遞參數的問題，也有可能是虛擬機的問題，反正開發者不應該關註的異常。

　　check exception表明調用方必須捕獲並處理該異常，一般是與運行時有關的錯誤，例如IO未準備好，文件不存在等，需要開發者關註的異常。

　　如果不想處理check exception，也可以在自己的方法裏直接聲明拋出異常throws XXXException即可，

●throw是語句拋出一個異常。

　　語法：throw (異常對象);

　　　　　　throw e;

●throws是方法可能拋出異常的聲明。(用在聲明方法時，表示該方法可能要拋出異常)

　　語法：[(修飾符)](返回值類型)(方法名)([參數列表])[throws(異常類)]{......}

　　　　　　public void doA(int a) throws Exception1,Exception3{......}

●log4j日誌：

%d：用來設置輸出日誌的日期和時間

%m:用來輸出代碼中指定的消息

%n:用來輸出一個回車換行符

%l:用來輸出日誌事件的發生位置

%p:用來輸出優先級

%f:用來輸出文件名

%m:用來輸出方法名

%t: 輸出產生該日誌事件的線程名，