java===Exception異常處理

時間 2019-11-25

原文原文鏈接

package cn.china;
/**
 * 異常：在運行時期發生的不正常狀況。
 * 問題不少，意味着描述的類也不少，
 * 將其共性進行向上抽取，造成異常體系。
 * 最終問題就分紅兩大類：
 * throwable:不管是Error，仍是異常，都是問題，就應該能夠拋出，讓調用者知道並處理。
 * 該體系的特色就在於throwable及其全部子類都具備可拋性。
 * 如何體現可拋性？
 * 實際上是經過兩個關鍵字體現的，throws,throw;凡是能夠被這兩個關鍵字操做的類和對象都具備可拋性。
 *    一、通常不可處理的，Error
 *    特色：是由JVM拋出的嚴重性問題，已經影響到咱們程序的執行；這種問題發生通常不針對性處理，直接修改程序
 *    二、能夠處理的，Exception
 *     特色：子類的後綴名都是用其父類名做爲後綴，閱讀性很強。
 *     
 *     異常分類：
 *     一、編譯時被檢測異常：只要是Exception和其子類都是，除了RunTimeException和其子類
 *     這種問題一旦出現，但願在編譯時就進行檢測，讓這種問題有對應的處理方式。
 *     這樣的問題均可以針對性的處理
 *     二、編譯時不檢測異常（運行時異常）：RunTimeException和其子類。
 *     這樣的問題的發生，沒法讓功能繼續，運算沒法進行，更可能是由於調用的緣由致使的或者引起了內部狀態的改變致使的。
 *     這種問題通常不處理，直接編譯經過，在運行時，讓調用者調用時的程序強制中止，讓調用者對代碼進行調整。
 *     
 *     throw 和 throws區別？
 *     throws 使用在函數上  拋出的是異常類，能夠拋出多個能夠用逗號隔開
 *     throw 使用在函數內   拋出的是異常對象*/
class FuShuIndexException extends Exception//因此這裏能夠繼承RunTimeException,就不須要聲明或者捕捉異常，編譯不會失敗
{
    public FuShuIndexException(String meg) {
        super(meg);
        // TODO Auto-generated constructor stub
    }
}
class D{
    public int method(int arr[],int index)throws FuShuIndexException
    {
        if(arr==null)
            throw new NullPointerException("數組的引用不能爲空！");
        if(index>=arr.length)
            throw new ArrayIndexOutOfBoundsException("數組越界了！"+index);
        if(index<0)//準備用負數角標異常來表示，可是這種異常在java中並無定義過。按照java異常的建立思想，將負數角標進行自定義描述，並封裝成對象
            throw new FuShuIndexException("數組的角標不能爲負數"+index);
        return arr[index];
    }
}
public class Demo {

    public static void main(String[] args) throws FuShuIndexException
    {
        int[]arr=new int[3];
        D d=new D();
        int num= d.method(arr, -30);
       
    }
    

}

package cn.china;
/**異常處理的捕捉形式
 * 具體格式：
 * try
 * {須要被檢測異常的代碼}
 * catch(異常類  變量)  //該變量用於接收發生異常的對象
 * {處理異常的代碼}
 * finally
 * {必定會被執行的代碼}
 * 
 * 
 * 異常處理原則：
 * 一、函數內部若是拋出須要檢測的異常，那麼函數上必需要聲明，不然必須在函數內必需要用trycatch捕捉，不然編譯失敗。
 * 二、若是調用到了聲明異常的函數，要麼trycatch要麼throws,不然編譯失敗。
 * 三、何時catch,何時throws呢？
 * 功能內部能夠解決，用catch;
 * 解決不了用throws，告訴調用者，調用者解決；
 * 四、一個功能若是拋出多個異常，那麼調用時必須由對應多個catch進行鍼對性處理。
 * 內部有幾個要檢測的異常，就拋幾個異常，拋出幾個，就catch幾個；*/
class FuShuIndexException extends Exception//因此這裏能夠繼承RunTimeException,就不須要聲明或者捕捉異常，編譯不會失敗
{
    public FuShuIndexException(String meg) {
        super(meg);
    }
}
class C{
    public int method(int arr[],int index)throws FuShuIndexException
    {
        if(arr==null)
            throw new NullPointerException("數組的引用不能爲空！");
        if(index>=arr.length)
            throw new ArrayIndexOutOfBoundsException("數組越界了！"+index);
        if(index<0)//準備用負數角標異常來表示，可是這種異常在java中並無定義過。按照java異常的建立思想，將負數角標進行自定義描述，並封裝成對象
            throw new FuShuIndexException("數組的角標不能爲負數"+index);
        return arr[index];
    }
}
public class Demo1 {

    public static void main(String[] args) {
        int[]arr=new int[3];
        C c=new C();
        try
        {
        int num= c.method(arr, -30);
        System.out.println("num"+num);//num是局部變量 因此這兩句話要放在同一個代碼塊
        }
        catch(NullPointerException e){//多catch格式
            e.printStackTrace();
        }
        catch(ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
        }
        catch(FuShuIndexException e)
        {
            e.printStackTrace();//JVM默認的異常處理機制就是調用異常對象的這個方法。
            System.out.println("Message"+e.getMessage());
            System.out.println("String"+e.toString());
            System.out.println("負數角標異常！");
        }
        catch(Exception e){//父類須要放在最下面，否則編譯失敗，由於Exception跟全部異常都匹配，
            e.printStackTrace();
        }
        System.out.println("over!");

    }

}

package cn.china;
/**try  catch  finally 組合特色
 * 一、 try  catch  finally
 * 二、try  catch(多個當沒有必要資源須要釋放時，能夠不用定義finally)
 * 三、 try  finally
 * 例：void show()throws Exception //由於沒有catch因此必須聲明異常
 * {
 *  try{
 *  //開啓資源
 *  throw new Exception
 *  }
 *  finally{
 *  //關閉資源
 *  }
 * }*/
class E{
    public int method(int  index)
    {
        int[]arr=new int[3];
        if(index>=arr.length)
            throw new ArrayIndexOutOfBoundsException();
        return arr[index];
    }
}
public class Demo2 {

    public static void main(String[] args) {
        E e=new E();
        try{int num=e.method(3);
        System.out.println(num);
        }catch(ArrayIndexOutOfBoundsException c)
        {
            System.out.println(c.toString());
            return;
            //System.exit(0); 退出JVM只有這種狀況不會執行finally語句；
        }
        finally {//必定會被執行的語句,主要用於關閉或者釋放資源
            System.out.println("finally");
        }
        System.out.println("over!");

    }

}

package cn.china;

import java.time.format.TextStyle;

/**
 * 畢老師用電腦上課，
 * 分析其中問題：
 * 電腦藍屏，冒煙*/
class LanPingException extends Exception
{
    LanPingException(String msg){
        super(msg);
    }
}
class MaoYanException extends Exception
{
    MaoYanException(String msg){
        super(msg);
    }
}
class NoPlanException extends Exception{
    NoPlanException(String msg){
        super(msg);
    }
}
class Computer{
    private int state=0;
    public void run()throws LanPingException,MaoYanException
    {
        if(state==1)
          throw new LanPingException("藍屏啦");
        if(state==2)
            throw new MaoYanException("電腦冒煙了");
        System.out.println("電腦運行");
    }
    public void reset(){
        state=0;
        System.out.println("電腦重啓了");
    }
}
class Teacher{
    private String  name;
    private Computer comp;
    Teacher(String name){
        this.name=name;
        comp=new Computer();
    }
    public void prelect()throws NoPlanException
    {
        try
        {
            comp.run();
            System.out.println("講課");
        }catch(LanPingException e){
            System.out.println(e.toString());
            comp.reset();
            prelect();
        }catch(MaoYanException e){
            System.out.println(e.toString());
            test();
            throw new NoPlanException("課時沒法進行"+e.getMessage());
            //能夠對電腦進行維修
            //throw e;
        }
    }
    public void test(){
        System.out.println("你們練習");
    }
}
public class Demo3 {

    public static void main(String[] args) {
        Teacher teacher=new Teacher("畢老師");
        try
        {
            teacher.prelect();
        }
        catch(NoPlanException e)
        {
            System.out.println(e.toString()+"......");
            System.out.println("換人");
        }


    }

}
/**
 * class NoAddException extends Exception{}
 * void addData(Data d)throws NoAddException
 * {
 *    連接數據庫
 *    try{
 *    添加數據庫，出現異常 SQLException();
 *    }catch(SQLException e)
 *    {
 *        //處理代碼
 *        throw new NoAddException();
 *    }finally
 *    {
 *         
 *    關閉數據庫
 *    }
 * }*/

package cn.china;
/**異常的注意事項
 * 一、子類在覆蓋父類方法時若是父類的方法拋出異常，那麼子類的方法只能破案出父類的異常，或者該異常的子類
 * 二、若是父類拋出多個異常，那麼子類子還能拋出父類異常的子集
 * 
 * 簡單說：子類覆蓋父類，只能拋出父類的異常，或者子集；若是父類沒有拋出異常，那麼子類覆蓋時絕對不能拋出異常，可是能夠用try;*/
class A extends Exception 
{
}
class B extends A
{}
class C extends Exception
{}
class Fu{
    void show()throws A{}
}
class Zi extends Fu{
    void show()throws B{}//只能拋出A或者B 
}
class Test{
    void method(Fu f){
        try{
            f.show();
        }catch(A a){}
    }
}
public class Demo4 {

    public static void main(String[] args) {
        Test t=new Test();
        t.method(new Zi());

    }

}