1 異常和IO

1.1異常的概述和分類

* A:異常的概述

* 異常就是Java程式在執行過程中出現的錯誤。

* B:異常的分類

* 通過API檢視Throwable

* Error

* 伺服器宕機,資料庫崩潰等

* Exception

C:異常的繼承體系

* Throwable

* Error

* Exception

* RuntimeException

1.2 JVM預設是如何處理異常的

* A:JVM預設是如何處理異常的

* main函式收到這個問題時,有兩種處理方式:

* a:自己將該問題處理,然後繼續執行

* b:自己沒有針對的處理方式,只有交給呼叫main的jvm來處理

* jvm

* 並將該異常的名稱,異常的資訊.異常出現的位置列印在了控制檯上,同時將程式停止執行

1.3 try...catch的方式處理異常

* A:異常處理的兩種方式

* a:try…catch…finally

* try catch

* try catch finally

* try finally

* b:throws

* B:try...catch處理異常的基本格式

* try…catch…finally

* C:案例演示

* try...catch的方式處理1個異常

try:用來檢測異常的

catch:用來捕獲異常的

finally:釋放資源

public
 
 class Demo2_TryCatchF {
    public static void main(String[] args) {
        ArithmeticExceptionDemo a = new ArithmeticExceptionDemo();
        /**
         * 只要try當中的內容出現錯誤，try下面的語句就不會在執行，就直接跳到catch語句執行
         * try語句如果沒有錯誤，catch的內容就不會執行
         */
        try{
            int v = a.division(55 , 0);
            System.out.println(v);
            System.out.println(
 
"+++++++++++++++++++++");
            // Exception e = new ArithmeticException(); 多型，父類引用指向子類物件
        }catch (Exception e){
            //e.printStackTrace();     // 打印出異常的所有資訊
            System.out.println(e.getMessage());  // 列印異常資訊
            System.out.println("出錯了，你除了零了");  // 相當於你把程式的錯誤已經處理了
        }
        // 當你使用了try...catch異常處理機制後，後面的程式會正常執行。
        System.out.println("-------------------");
    }
}

1.4編譯期異常和執行期異常的區別

* A:編譯期異常和執行期異常的區別

* Java中的異常被分為兩大類：編譯時異常和執行時異常。

* 所有的RuntimeException類及其子類的例項被稱為執行時異常，其他的異常就是編譯時異常

* 編譯時異常

* Java程式必須顯示處理，否則程式就會發生錯誤，無法通過編譯

* 執行時異常

* 無需顯示處理，也可以和編譯時異常一樣處理

2 Throwable的幾個常見方法

* A:Throwable的幾個常見方法

* a:getMessage()

* 獲取異常資訊，返回字串。

* b:toString()

* 獲取異常類名和異常資訊，返回字串。

* c:printStackTrace()

* 獲取異常類名和異常資訊，以及異常出現在程式中的位置。返回值void。

* B:案例演示

* Throwable的幾個常見方法的基本使用

package com.jhedu.day20;
import me.jhedu.article.Student;
public class Demo5_StudentAge {
    public static void main(String[] args) {
        /**
         * 在實際的開發過程中，try和catch的使用率要高於throw和throws
         */
        Student s = new Student();
        try {
            s.setAge(-17);
        } catch (Exception e) {
            //e.printStackTrace();
            System.out.println("年齡不和法");
        }
        System.out.println("++++");
    }
}
public void setAge(int age)  {
    /**
     * 在程式當中設定丟擲異常的方法使用的就是throws,具體用在方法的宣告上面，也就是在
     * 左邊的花括號前面，而在小括號的後面，不同的異常使用，分割開.
     * 而throw的使用是在方法體內，只可以丟擲異常類的物件
    */
   if(age >0 && age <= 150) {
        this.age = age;
    }else {
        RuntimeException e = new RuntimeException();
        throw e;  // 屬於編譯異常，需要在方法宣告中新增throws異常
    }

}

2.1 throws的方式處理異常

* A:throws的方式處理異常

* 定義功能方法時，需要把出現的問題暴露出來讓呼叫者去處理。

* 那麼就通過throws在方法上標識。

方法中如果丟擲執行時物件的話，方法上不用宣告一個可以。要是編譯時異常的話就必須宣告

2.3 throw的概述以及和throws的區別

* A:throw的概述

* 在功能方法內部出現某種情況，程式不能繼續執行，需要進行跳轉時，就用throw把異常物件丟擲。

* C:throws和throw的區別

* a:throws

* 用在方法聲明後面，跟的是異常類名

* 可以跟多個異常類名，用逗號隔開

* 表示丟擲異常，由該方法的呼叫者來處理

* b:throw

* 用在方法體內，跟的是異常物件名

* 只能丟擲一個異常物件名

* 表示丟擲異常，由方法體內的語句處理

2.4 finally關鍵字的特點及作用

* A:finally的特點

* 被finally控制的語句體一定會執行

* 特殊情況：在執行到finally之前jvm退出了(比如System.exit(0))

* B:finally的作用

* 用於釋放資源，在IO流操作和資料庫操作中會見到

Io流是需要開啟的，開啟之後需要關閉。在finally裡面關閉

Finally強大到用return結束方法也會執行。

2.5 finally關鍵字的面試題

* A:面試題1

* final,finally和finalize的區別

final用於宣告屬性，方法和類，分別表示屬性不可交變，方法不可覆蓋，類不可繼承。
finally是異常處理語句結構的一部分，表示總是執行。
finalize是Object類的一個方法，在垃圾收集器執行的時候會呼叫被回收物件的此方法，供垃圾收集時的其他資源回收，例如關閉檔案等。

* B:面試題2

* 如果catch裡面有return語句，請問finally的程式碼還會執行嗎?如果會，請問是在return前還是return後？

finally塊的語句在try或catch中的return語句執行之後返回之前執行

若finally語句中沒有return，則其執行結果不影響try和catch中已確定的返回值

finally裡的修改語句可能影響也可能不影響try或catch中 return已經確定的返回值

若finally裡也有return語句則覆蓋try或catch中的return語句直接返回。

2.6 自定義異常概述和基本使用

* A:為什麼需要自定義異常

異常有很多子類就是為了讓你更好的知道丟擲的是啥異常

為了有利於你排錯，報不同異常代表不同的錯誤。看了名字就知道犯了什麼錯誤

就是為了有個名字而已。所做的事情父類都去做了。

* 舉例：人的年齡---拋一個屬於自己的異常

* B:自定義異常概述

* 繼承自Exception

* 繼承自RuntimeException

* C:案例演示

* 自定義異常的基本使用

package com.jhedu.day20;
/**
 * * A:為什麼需要自定義異常
 * 通過名字區分到底是什麼異常,有針對的解決辦法
 * 舉例：人的年齡
 * B:自定義異常概述
 * 繼承自Exception
 * 繼承自RuntimeException
 * C:案例演示
 * 自定義異常的基本使用
 */
public class Demo7_SelfException {
    /**
     *
     * @param args
     * @throws AgeOutOfBoundsException  自定義異常
     */
    public static void main(String[] args) throws AgeOutOfBoundsException {
        Person p = new Person();
        // 捕獲異常
       try{
           p.setAge(17);
           System.out.println(p.getAge());
       }catch (Exception e){
           System.out.println("年齡非法");
       }
    }
}

package com.jhedu.day20;
public class Person {
    private String name;
    private int age;
    public Person() {
        super();
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) throws AgeOutOfBoundsException {
        if(age >0 && age <= 150) {
            this.age = age;
        }else {
            throw new AgeOutOfBoundsException("年齡非法");
        }
    }
}

package com.jhedu.day20;
public class AgeOutOfBoundsException extends Exception {
    // 空引數的構造方法
    public AgeOutOfBoundsException() {
        super();   // 呼叫父類Exception的構造方法
    }
    // 有引數的構造方法
    public AgeOutOfBoundsException(String message) {
        super(message);  // 呼叫父類Exception的有引數構造方法
    }
}

2.7異常的注意事項及如何使用異常處理

* A:異常注意事項

* a:子類重寫父類方法時，子類的方法必須丟擲相同的異常或父類異常的子類。(父親壞了,兒子不能比父親更壞)

* b:如果父類丟擲了多個異常,子類重寫父類時,只能丟擲相同的異常或者是他的子集,子類不能丟擲父類沒有的異常

* c:如果被重寫的方法沒有異常丟擲,那麼子類的方法絕對不可以丟擲異常,如果子類方法內有異常發生,那麼子類只能try,不能throws

* B:如何使用異常處理

* 原則:如果該功能內部可以將問題處理,用try,如果處理不了,交由呼叫者處理,這是用throws

* 區別:

* 後續程式需要繼續執行就try

* 後續程式不需要繼續執行就throws

* 如果JDK沒有提供對應的異常，需要自定義異常。