java物件導向（異常）

1. 異常：就是程式在執行時出現不正常情況

異常由來：問題也是現實生活中一個具體的事物，也可以透過java的類形式進行描述。並封裝成物件。其實就是  java對不正常情況進行描述後的物件體現。

對於嚴重的，java透過error類進行描述

    對於error一般不編寫針對性的程式碼對其進行處理

對於非嚴重的，java透過exception類進行描述。

     對於exception可以使用針對性的處理方式進行處理

無論Error或者Exception都具有一些共性內容。
比如：不正常情況的資訊，引發原因等。
異常體系：
    Throwable
        |--Error
        |--Exception
            |--RuntimeException

2,異常的處理
java 提供了特有的語句進行處理。
try
{
    需要被檢測的程式碼；
}
catch(異常類 變數)
{
    處理異常的程式碼；(處理方式)
}
finally
{
    一定會執行的語句；通常用於關閉資源。
}
有三個結合格式：
1)   try
    {
    }
    catch ()
    {
    }
2)    try
    {
    }
    finally
    {
    }
3)    try
    {
    }
    catch ()
    {
    }
    finally
    {
    }

注意：
finally中定義的通常是 關閉資原始碼。因為資源必須釋放。
finally只有一種情況不會執行。當執行到System.exit(0);fianlly不會執行。

3，對捕獲到的異常物件進行常見方法操作。
    String getMessage()：獲取異常資訊。

當函式內容有throw丟擲異常物件，並未進行try處理。必須要在函式上宣告，都在編譯失敗。
注意，RuntimeException除外。也就說，函式內如果丟擲的RuntimeExcpetion異常，函式上可以不用宣告。

如果函式宣告瞭異常，呼叫者需要進行處理。處理方法可以throws可以try。

---

class Demo
{
     int div(int a,int b)throws Exception //在功能上透過throws的關鍵字宣告瞭該功能有可能會出現問題
     {
         return a/b;
     }
}
public class ExceptionDemo {
    public static void main(String[] args)//throws Exception

  {
        Demo d=new Demo();
        //int x=d.div(4, 1);
        //System.out.println("x="+x);
        try
        {
                int x=d.div(4, 1);
                System.out.println("x="+x);
        }
        catch(Exception e)
        {
            System.out.println("除零啦");
            System.out.println(e.getMessage()); // /by zero
            System.out.println(e.toString());//異常名稱：異常資訊
            e.printStackTrace();//異常名稱，異常資訊，異常出現的位置。
                               //其實jvm預設的異常處理機制，就是在呼叫printStackTrace方法。
                               //列印異常的堆疊的跟蹤資訊。
        }
    }
}

---

4.對多異常的處理。
1，宣告異常時，建議宣告更為具體的異常。這樣處理的可以更具體。
2，對方宣告幾個異常，就對應有幾個catch塊。不要定義多餘的catch塊。
    如果多個catch塊中的異常出現繼承關係，父類異常catch塊放在最下面。
建立在進行catch處理時，catch中一定要定義具體處理方式。
不要簡單定義一句 e.printStackTrace(),
也不要簡單的就書寫一條輸出語句。

---

class Demo
{
     int div(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException //在功能上透過throws的關鍵字宣告瞭該功能有可能會出現問題
     {
        int[] arr=new int [a];
        System.out.println(arr[4]);
         return a/b;
     }
}
public class ExceptionDemo {
    public static void main(String[] args) //throws Exception
    {
        Demo d=new Demo();
        //int x=d.div(4, 1);
        //System.out.println("x="+x);
        try
        {
                int x=d.div(2, 0);
                System.out.println("x="+x);
        }
        catch(ArithmeticException e)
        {
            System.out.println("除零啦");
            e.printStackTrace();//異常名稱，異常資訊，異常出現的位置。
                               //其實jvm預設的異常處理機制，就是在呼叫printStackTrace方法。
                               //列印異常的堆疊的跟蹤資訊。
        }
        catch(ArrayIndexOutOfBoundsException e)
        {
            System.out.println("越界啦");
            e.printStackTrace();//異常名稱，異常資訊，異常出現的位置。
                               //其實jvm預設的異常處理機制，就是在呼叫printStackTrace方法。
                               //列印異常的堆疊的跟蹤資訊。
        }
        //System.out.println("over");
    }
}
執行結果：

越界啦
java.lang.ArrayIndexOutOfBoundsException: 4
    at Demo.div(ExceptionDemo.java:6)
    at ExceptionDemo.main(ExceptionDemo.java:23)

---

5.自定義異常。
因為專案中會出現特有的問題，
而這些問題並未被java所描述並封裝物件。
所以對於這些特有的問題可以按照java的對問題封裝的思想。
將特有的問題。進行自定義的異常封裝。
需求：在本程式中，對於除數是-1，也視為是錯誤的是無法進行運算的。
那麼就需要對這個問題進行自定義的描述。
當在函式內部出現了throw丟擲異常物件，那麼就必須要給對應的處理動作。
要麼在內部try catch處理。
要麼在函式上宣告讓呼叫者處理。
一般情況在，函式內出現異常，函式上需要宣告。

發現列印的結果中只有異常的名稱，卻沒有異常的資訊。
因為自定義的異常並未定義資訊。
如何定義異常資訊呢？
因為父類中已經把異常資訊的操作都完成了。
所以子類只要在構造時，將異常資訊傳遞給父類透過super語句。
那麼就可以直接透過getMessage方法獲取自定義的異常資訊。
自定義異常：
必須是自定義類繼承Exception。
繼承Exception原因：
異常體系有一個特點：因為異常類和異常物件都被丟擲。
他們都具備可拋性。這個可拋性是Throwable這個體系中獨有特點。
只有這個體系中的類和物件才可以被throws和throw操作。
6. throws和throw的區別
throws使用在函式上。
throw使用在函式內。
throws後面跟的異常類。可以跟多個。用逗號隔開。
throw後跟的是異常物件。

---

class FuShuException extends Exception
{
    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 ArithmeticException,ArrayIndexOutOfBoundsException,FuShuException //在功能上透過throws的關鍵字宣告瞭該功能有可能會出現問題
     {
         if(b<0)
             //throw new FuShuException() ;
            throw new FuShuException("出現了除數是負數的情況 ----/by fushu",b) ;//手動透過throw關鍵字丟擲一個自定義異常
         return a/b;
     }
}
public class ExceptionDemo {
    public static void main(String[] args) //throws Exception
    {
        Demo d=new Demo();
        //int x=d.div(4, 1);
        //System.out.println("x="+x);
        try
        {
                int x=d.div(3, -1);
                System.out.println("x="+x);
        }
        catch(ArithmeticException e)
        {
            System.out.println("除零啦");
            e.printStackTrace();//異常名稱，異常資訊，異常出現的位置。
                               //其實jvm預設的異常處理機制，就是在呼叫printStackTrace方法。
                               //列印異常的堆疊的跟蹤資訊。
        }
        catch(ArrayIndexOutOfBoundsException e)
        {
            System.out.println("越界啦");
            e.printStackTrace();//異常名稱，異常資訊，異常出現的位置。
                               //其實jvm預設的異常處理機制，就是在呼叫printStackTrace方法。
                               //列印異常的堆疊的跟蹤資訊。
        }
        catch(FuShuException e)
        {
            //System.out.println("除數是負數");
            e.printStackTrace();//異常名稱，異常資訊，異常出現的位置。
                               //其實jvm預設的異常處理機制，就是在呼叫printStackTrace方法。
                               //列印異常的堆疊的跟蹤資訊。
            System.out.println("除數是負數:"+e.getValue());
        }
        //System.out.println("over");
    }
}

---

7.RuntimeException

Exceptoin中有一個特殊的子類異常RuntimeException 執行時異常。
如果在函式內丟擲該異常，函式上可以不用宣告，編譯一樣透過。
如果在函式上宣告瞭該異常。呼叫者可以不用進行處理。編譯一樣透過；

之所以不用在函式宣告，是因為不需要讓呼叫者處理。
當該異常發生，希望程式停止。因為在執行時，出現了無法繼續運算的情況，希望停止程式後，
對程式碼進行修正。
自定義異常時：如果該異常的發生，無法在繼續進行運算，
就讓自定義異常繼承RuntimeException。
對於異常分兩種：
1，編譯時被檢測的異常。
2，編譯時不被檢測的異常(執行時異常。RuntimeException以及其子類)

---

class FuShuException extends RuntimeException
{
    FuShuException(String msg)
    {
        super(msg);
    }
}
class Demo
{
    int div(int a,int b)//throws Exception//throws ArithmeticException
    {
        if(b<0)
            throw new FuShuException("出現了除數為負數了");
        //if(b==0)
            //throw new ArithmeticException("被零除啦");
        return a/b;
    }
}
public class ExceptionDemo {
    public static void main(String[] args) //throws Exception
    {
        Demo d=new Demo();
        int x=d.div(4, -1);
        System.out.println("x="+x);
    }
}

---