java異常知識點彙總

weixin_34292959發表於2016-09-21
Java

異常處理方法

　　對於非執行時異常（checked exception），必須要對其進行處理，否則無法通過編譯。

　　處理方式有兩種：

　　1.使用try..catch..finally進行捕獲；

　　2.在產生異常的方法宣告後面寫上throws 某一個Exception型別，如throws Exception，將異常丟擲到外面一層去。

對非執行時異常的處理詳見程式碼例子：

　　處理方式1：將異常捕獲

public class ExceptionTest2
{
    public void method() throws Exception // 將異常丟擲，由呼叫這個方法的方法去處理這個異常,如果main方法也將異常丟擲，則交給Java虛擬機器來處理
    {
        System.out.println("Hello World");

        // 丟擲異常
        throw new Exception();
    }

    public static void main(String[] args)
    {
        ExceptionTest2 test = new ExceptionTest2();

        try
        {
            test.method();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            System.out.println("Welcome");
        }


    }

}

處理方式2：將異常繼續向外丟擲

public class ExceptionTest2
{
    public void method() throws Exception // 將異常丟擲，由呼叫這個方法的方法去處理這個異常,如果main方法也將異常丟擲，則交給Java虛擬機器來處理
    {
        System.out.println("Hello World");

        // 丟擲異常
        throw new Exception();
    }

    public static void main(String[] args) throws Exception // main方法選擇將異常繼續丟擲
    {
        ExceptionTest2 test = new ExceptionTest2();

        test.method(); // main方法需要對異常進行處理

        // 執行結果：
        // Hello World
        // Exception in thread "main" java.lang.Exception
        // at com.learnjava.exception.ExceptionTest2.method(ExceptionTest2.java:10)
        // at com.learnjava.exception.ExceptionTest2.main(ExceptionTest2.java:17)
    }

}

對於執行時異常（runtime exception），可以對其進行處理，也可以不處理。推薦不對執行時異常進行處理。

自定義異常

　　所謂自定義異常，通常就是定義一個類，去繼承Exception類或者它的子類。因為異常必須直接或者間接地繼承自Exception類。

　　通常情況下，會直接繼承自Exception類，一般不會繼承某個執行時的異常類。

　　自定義異常可以用於處理使用者登入錯誤，使用者輸入錯誤提示等。

　　自定義異常的例子：

　　自定義一個異常型別：　

public class MyException extends Exception
{
    public MyException()
    {
        super();
    }    
    public MyException(String message)
    {
        super(message);
    }
}

一種異常處理方式

public class ExceptionTest4
{

    public void method(String str) throws MyException
    {
        if(null == str)
        {
            throw new MyException("傳入的字串引數不能為null！");
        }
        else
        {
            System.out.println(str);
        }
    }
    
    public static void main(String[] args) throws MyException //異常處理方式1，不斷向外丟擲
    {
        ExceptionTest4 test = new ExceptionTest4();
        test.method(null);
    }
}

另一種異常處理方式：

public class ExceptionTest4
{

    public void method(String str) throws MyException
    {
        if (null == str)
        {
            throw new MyException("傳入的字串引數不能為null！");
        }
        else
        {
            System.out.println(str);
        }
    }

    public static void main(String[] args)
    {
        //異常處理方式2，採用try...catch語句
        try
        {
            ExceptionTest4 test = new ExceptionTest4();
            test.method(null);

        }
        catch (MyException e)
        {
            e.printStackTrace();
        }    
        finally
        {
            System.out.println("程式處理完畢");
        }

    }
}

 

前面說過，可以有多個catch塊，去捕獲不同的異常，真正執行的時候最多隻進入一個catch塊。

　　下面這個例子，定義了兩種自定義的異常型別：

public class MyException extends Exception
{

    public MyException()
    {
        super();
    }
    
    public MyException(String message)
    {
        super(message);
    }
}


public class MyException2 extends Exception
{
    public MyException2()
    {
        super();
    }
    public MyException2(String message)
    {
        super(message);
    }

}


public class ExceptionTest4
{

    public void method(String str) throws MyException, MyException2
    {
        if (null == str)
        {
            throw new MyException("傳入的字串引數不能為null！");
        }
        else if ("hello".equals(str))
        {
            throw new MyException2("傳入的字串不能為hello");
        }
        else
        {
            System.out.println(str);
        }
    }

    public static void main(String[] args)
    {
        // 異常處理方式2，採用try...catch語句
        try
        {
            ExceptionTest4 test = new ExceptionTest4();
            test.method(null);

        }
        catch (MyException e)
        {
            System.out.println("進入到MyException catch塊");
            e.printStackTrace();
        }
        catch (MyException2 e)
        {
            System.out.println("進入到MyException2 catch塊");
            e.printStackTrace();
        }
        finally
        {
            System.out.println("程式處理完畢");
        }

    }
}

我們可以使用多個catch塊來捕獲異常，這時需要將父型別的catch塊放到子型別的catch塊之後，這樣才能保證後續的catch塊可能被執行，否則子型別的catch塊將永遠無法到達，Java編譯器會報錯。

如果異常型別是獨立的，那麼它們的前後順序沒有要求。

如對上面的程式碼進行改動後，如下列出：

public class ExceptionTest4
{

    public void method(String str) throws Exception // 也可以宣告Exception，只要宣告的可以涵蓋所有丟擲的異常即可
    {
        if (null == str)
        {
            throw new MyException("傳入的字串引數不能為null！");
        }
        else if ("hello".equals(str))
        {
            throw new MyException2("傳入的字串不能為hello");
        }
        else
        {
            System.out.println(str);
        }
    }

    public static void main(String[] args)
    {
        // 異常處理方式2，採用try...catch語句
        try
        {
            ExceptionTest4 test = new ExceptionTest4();
            test.method(null);

        }
        catch (MyException e)
        {
            System.out.println("進入到MyException catch塊");
            e.printStackTrace();
        }
        catch (MyException2 e)
        {
            System.out.println("進入到MyException2 catch塊");
            e.printStackTrace();
        }
        catch (Exception e)
        {
            //雖然需要加上，但是這塊程式碼不會被執行，只是為了編譯成功
            System.out.println("進入到MyException catch塊");
            e.printStackTrace();
            //如果去掉前面兩個catch塊或其中之一，則發生該異常時就會進入此catch塊
            //catch塊的匹配是按照從上到下的順序，所以這個塊如果放在最前面就會捕獲所有的異常，後面的塊永遠不會執行，這時候會提示編譯錯誤
        }
        finally
        {
            System.out.println("程式處理完畢");
        }

    }
}

面試常考題型

　　try塊中的退出語句

　　雖然實際開發中不會遇到這樣的情況，但是筆試面試時有關異常經常會問到如下情況:

public class ExceptionTest5
{

    public void method()
    {
        try
        {
            System.out.println("進入到try塊");
            
            //return;
            //會先執行finally塊再返回
            
            //虛擬機器退出
            //System.exit(0);
            //不會執行finally塊中的語句，直接退出
        }
        catch (Exception e)
        {
            System.out.println("異常發生了！");
            
        }
        finally
        {
            System.out.println("進入到finally塊");
            
        }
        
        System.out.println("後續程式碼");
        
    }
    
    public static void main(String[] args)
    {
        ExceptionTest5 test = new ExceptionTest5();
        test.method();
    }
}

 


　　在加上return語句前，程式輸出：

　　　　進入到try塊

　　　　進入到finally塊

　　　　後續程式碼

 

　　如果在try塊中加入return語句：

　　程式執行輸出：

　　　　進入到try塊

　　　　進入到finally塊

 

　　說明try塊中有return語句時，仍然會首先執行finally塊中的語句，然後方法再返回。

　　如果try塊中存在System.exit(0);語句，那麼就不會執行finally塊中的程式碼，因為System.exit(0)會終止當前執行的Java虛擬機器，程式會在虛擬機器終止前結束執行。

 本文轉載自http://www.cnblogs.com/mengdd/archive/2013/02/03/2890923.html，感謝原作者

相關文章