年前規劃

JavaSE高階
	異常
	集合
	IO
	網路程式設計
	反射
	Java8+新特性
Linux 作業系統
Oralce
第一階段專案：基於Swing

異常

異常的定義

一場就是在程式編譯和執行期間，所產生的一種不正常結果；

異常指程式執行過程中出現的非正常現象，例如使用者輸入錯誤、除數為零、需要處理的檔案不存在、陣列下標越界等。

在 Java 的異常處理機制中，引進了很多用來描述和處理異常的類，稱為異常類。

異常類定義中包含了該類異常的資訊和對異常進行處理的方法。

所謂異常處理，就是指程式在出現問題時依然可以正確的執行完。

常見的RunTimeException

		// 執行時異常
		// IndexOutOfBoundsException
        int[] arr = new int[5];
        System.out.println(arr[5]);

        //空指標異常 NullPointException
        String str = null;
        System.out.println(str.equals("abc"));

        // 型別轉換異常 ClassCastException
        Object obj = new String();
        Integer inte = (Integer) obj;

        // 算術異常
        System.out.println(1/0);

// 解析異常
        String strDate = "2020-12-23";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = sdf.parse(strDate); // 有可能發生異常 必須處理不處理程式無法正常執行
        System.out.println(date);

異常對程式產生的影響

當發生異常的時候 程式就會終止，異常程式碼之後的 程式將不在執行。

異常的處理

編譯期異常和執行時異常的區別：

1. 執行時異常不處理，不會影響程式的執行，而執行期異常則必須做出相應的處理，否則程式無法執行。
2. 執行時異常往往都可以通過優化程式碼來進行規避，執行時異常的出現，都是我們的程式存在邏輯上的漏斗或者缺陷。

在實際處理中 處理的重點編譯期異常

Java中對異常的處理，提供了一種異常處理模型——抓拋模型

捕獲異常

try{
	包含有可能異常的程式碼;
}catch(異常型別 變數){
	針對這種異常的處理;
}finally{
	無論程式是否異常，都需要執行的程式碼;
}

// 解析異常 ParseException
String strDate = "2020-12-23 " ;
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = null;// 有可能發生異常  必須處理 不處理程式無法正常執行
try {
    date = sdf.parse(strDate);
} catch (ParseException e) {
    e.printStackTrace();
}
System.out.println(date);

通過catch捕獲異常，並對異常做出相應的處理 這樣就可以保證程式繼續執行

可以同時有多個catch塊

try {
            System.out.println(arr[5]);
            System.out.println(str.equals("abc"));
            Integer inte = (Integer) obj;
            System.out.println(1/0);
            date = sdf.parse(strDate);
        } catch (ParseException e) {
            System.out.println("異常處理");
            e.printStackTrace();
        }catch (ArrayIndexOutOfBoundsException ae) {
            System.out.println("處理陣列下標越界異常");
        }catch (NullPointerException ne){
            System.out.println("處理空指標異常");
        }

多異常捕獲

try {
    Integer inte = (Integer)obj;
    System.out.println(arr[5]);
    System.out.println(str.equals("abc"));

    System.out.println(1/0);
    date = sdf.parse(strDate);
} catch (ParseException |ArrayIndexOutOfBoundsException |NullPointerException e) {
    System.out.println("異常處理");
    e.printStackTrace();
}

通過異常的多型來捕獲

try {

    System.out.println(arr[5]);
    System.out.println(str.equals("abc"));
    Integer inte = (Integer)obj;
    System.out.println(1/0);
    date = sdf.parse(strDate);
} catch (Exception e) {
    System.out.println("異常處理");
   // e.printStackTrace();
}

這種寫法僅限於jkd7以上

可以這樣寫。

try {
    Integer inte = (Integer)obj;
    System.out.println(arr[5]);
    System.out.println(str.equals("abc"));

    System.out.println(1/0);
    date = sdf.parse(strDate);
} catch (ParseException e) {
    System.out.println("異常處理");
    e.printStackTrace();
}catch (ArrayIndexOutOfBoundsException ae){

}catch (NullPointerException ne){

}catch (Exception ee){
    
}

捕獲異常 將有可能發生異常的程式碼寫在try塊中，當發生異常的時候 ，就會執行相應的catch塊的內容 可以保證異常處理之後的程式碼的正常執行，從而使得程式可以正常終止

在程式設計時，只需將有可能發生異常的程式碼放在try塊中，而不要將沒有異常發生的程式碼新增到try，這樣會影響程式的執行的效率

異常資訊的分析

異常資訊的描述



在異常體系中，所有的子類都沒有具體方法，方法都是來自於Throwable

} catch (ParseException e) {
    System.out.println("異常處理");
    e.printStackTrace();
}catch (ArrayIndexOutOfBoundsException ae){
    System.out.println("陣列下標越界");
    ae.printStackTrace();
    String message = ae.getMessage();//Index 5 out of bounds for length 5
    System.out.println(message);
}catch (NullPointerException ne){
    ne.printStackTrace();
}catch (Exception ee){
    ee.printStackTrace();//得到的異常的全部資訊 
    String msg= ee.toString();
    System.out.println(msg);
}

第二種處理方式：丟擲異常

//將String型別轉換為Date  解析
public static Date str2Date(String strDate) throws ParseException {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    Date date =  sdf.parse(strDate);
    return  date;
}

丟擲異常是在方法的宣告上，通過throws 關鍵字來進行宣告

告訴方法的呼叫者，該方法存在這樣型別的異常，throws後邊跟的是異常型別。

//將String型別轉換為Date  解析
public static Date str2Date(String strDate) throws ParseException, IOException {
    File file = new File("src/str.txt");
    file.delete();
    file.canWrite();
    file.getCanonicalPath();
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    Date date =  sdf.parse(strDate);
    return  date;
}

在throws後邊可以跟多個型別異常

丟擲異常是拋給了方法的呼叫者，此時對於方法的呼叫者來說將有兩種選擇：

第一種使用try{}catch{}來捕獲異常並處理

第二種則是不處理，繼續使用throws往外拋

JVM對於接受到的異常的預設處理

以上就是jvm的預設處理方式：

就是列印異常的堆疊資訊，並終止程式的執行。
對於與業務相關的異常，就需要我們自己來定義異常

自定義異常

有一個考試系統，需要老師來錄入學生的考試成績 ，如果老師錄入的成績是0-100則為正常，負責就丟擲一個成績不合法的異常資訊。
如何自定義異常：

自定義異常就兩種：

1. 一種是自定義編譯期異常
2. 另一種就是定義執行時異常

如果要自定義個一個編譯期異常 則繼承Exception即可 並實現相應的構造方法即可

如果要自定義一個執行時異常 則繼承RuntimeException 並實現相應的構造方法

//自定義一個成績異常
public class ScoreException extends  Exception{
    public ScoreException(){
        super();
    }
    //message表示顯示的錯誤資訊
    public ScoreException(String message){
        super(message);
    }
}

public class Teacher {
    public void recoderScore(int score) throws ScoreException {
        if(score >0 && score <=100){
            System.out.println("本次錄入的成績為：" + score);
        }else{
            // 手動丟擲異常
            throw new ScoreException("成績不合法");
        }
    }

    public static void main(String[] args) throws ScoreException {
        Teacher teacher = new Teacher();
        teacher.recoderScore(180);
    }
}

throw和throws的區別★

1. 位置：

throws用在方法的宣告上

throw在方法體

2. 丟擲型別

throws丟擲的是 異常的型別

throw丟擲的是異常物件

3. 數量

throws可以丟擲多個異常

throw只能丟擲 一個異常物件

什麼時候抓？什麼時候拋？★

捕獲異常都在我們可以自己處理並且處理之後不會再次產生新的異常時，才捕獲處理。

如果不能完全處理異常，則將異常丟擲給下一個方法的呼叫者，讓其來做出相應的處理，直到最後拋給jvm