java怎么捕捉除数异常_Java异常的捕获及处理---小总结
一：異常的基本概念
二：異常的基本處理格式
三：異常的繼承結構
四：Java的異常處理機制
五：throws和throw關鍵字的作用
六：Exception和RunntimeException的區別
七：自定義異常類
八：斷言的作用和應用
1，為什么需要異常處理？
異常是導致程序中斷執行的一種指令流。如果不對異常進行正確的處理，則可能導致程序的中斷執行，造成不必要的損失，所以
在程序的設計中必須要考慮各種異常的發生，并正確的做好相應的處理，這樣才能保證程序的正常執行。
一旦產生異常，異常之后的語句并不會被執行，而是直接結束程序，并將錯誤報告給客戶了。
2，異常的基本處理格式try—catch。try中捕獲異常，catch中處理對應的異常。
try中捕獲異常，出現異常之后的代碼將不再被執行，而是跳轉到相應的catch語句中執行，用于處理異常。
對于異常，也可以設置其統一的出口，使用fially完成。
3，異常類的繼承關系
在整個Java的異常結構中實際上有兩個最常用的異常類，Exception,Error,這兩個類全都是Throwable的子類，
Exception,一般表示的是程序中出現的問題，可以直接使用try-catch處理。
Error，一般指的是JVM錯誤，程序中無法處理。
一般情況下，開發者習慣于將Error,Exception統一稱為異常。
一般在輸出異常信息的時候，可以直接使用System.out.println進行打印異常對象。
首頁可以通過Exception提供的一個方法，public void printStackTrace();來打印異常信息。
4，Java的異常處理機制：
在整個Java的異常處理中，實際上也是按照面向對象的方式進行處理的，處理步驟：
1，一旦產生異常，則首先會產生一個異常類的實例化對象。
2，在try語句中對此異常對象進行捕捉。
3，產生的異常對象與catch語句中的各個異常類型進行匹配，如果匹配成功則執行catch語句中的代碼。
根據對象的多態性，子類的實例化對象可以直接使用父類的對象進行接收。
在異常的處理中，也是可以使用這樣的概念，因為try中產生的是一個實例化對象，如果現在有一些其他的無法知道
的異常，則可以最后使用Exception進行捕獲。
但是有一個注意點：捕獲更粗的異常要放在捕獲更細的異常之后。
又出現了一個問題：
既然所有的Exception對象都可以使用Exception接收，(都可以發生向上轉型關系)直接使用Exception捕獲異常不是更方便么？
這樣雖然可以統一全部捕獲到異常，但是在一個精細的開發中，是不建議這樣使用的，因為，這樣只是知道發生了異常，并不知道
具體發生了什么異常，所以，最好分別進行捕獲。
又有一個問題：
既然不過Exception是最方便的，那么直接捕獲它的父類，Throwable豈不是更好？
首先，這樣的做法是可以的，因為Exception是Throwable的子類，但是正常的開發人員是不會這樣做的，因為程序的try語句中永遠只會拋出Exception的子類對象，Throwable不僅僅有
Exception這個子類，還有Error這個子類。
1，程序出現異常之后，如果沒有合理的處理的話，則會導致程序的中斷執行。
2，使用try—catch,和try–catch–finally，可以處理異常。finally將會作為異常的統一出口，不管是否出現異常都會執行此語句。
3，一個異常處理中，可以同時出現多個catch，但是捕獲更粗的異常要放在捕獲更細的異常之后，否則程序編譯會報錯。
4，在異常中，最大的類Throwable，分為兩個子類，Exception，Error，其中Exception表示的是程序可以自己處理的異常，Error表示的是jvm錯誤，一般程序是無法處理的。
5，捕獲異常的時候，可以直接捕獲Exception，但是最好分開捕獲，如果所有的異常處理操作是一樣的話，則也可以直接捕獲Exception。
6，每當異常產生之后，會在程序中產生一個異常類的實例化對象，之后使用此對象與catch中的異常類型進行匹配，如果匹配成功則執行catch語句中的內容，如果匹配不成功，則
繼續向下匹配，如果都無法匹配成功，程序將出現中斷執行的情況。
5，在定義一個方法的時候，可以使用throws關鍵字聲明，使用throws聲明的方法表示此方法不處理異常，而是交給方法的調用處進行處理。
這樣一來，在后面調用這個除法的方法的時候就必須進行異常的處理。
throws使用格式： public 返回值類型 方法名稱(參數列表) throws 異常類{}
什么意思呢？比如說，定義一個2個數相除的操作方法，對于這個除法操作，可能會出現除數為0的異常，但是也可能不出現異常，對于這樣的操作，
其實最好就是將它使用throws關鍵字聲明，一旦出現了異常，則應該交給調用處去處理。
class Math{
public int div(int i,int j) throws Exception{ // 定義除法操作，如果有異常，則交給調用處處理
int temp = i / j ; // 計算，但是此處有可能出現異常
return temp ;
}
};
這樣一來，在后面調用這個除法的方法的時候就必須進行異常的處理。
那么問題來了，
這個div方法使用了throws聲明，就是說這個方法本身不做任何異常處理，如果產生異常交給調用處去處理，如果我調用處，調用這個方法，傳入的參數是正常的不會出現異常的參數的時候，也就是不會產生異常的情況下，我調用處沒有產生異常也就不進行異常處理，會有問題么？
什么意思呢？就是說，這樣的使用，會不會存在編譯錯誤？
class Math{
public int div(int i,int j) throws Exception{ // 定義除法操作，如果有異常，則交給被調用處處理
int temp = i / j ; // 計算，但是此處有可能出現異常
return temp ;
}
};
public class ThrowsDemo02{
// 調用處沒有進行異常的處理
public static void main(String args[]){
Math m = new Math() ; // 實例化Math類對象
System.out.println("除法操作：" + m.div(10,2)) ;
}
};
結果：
你瞧，編譯報錯了，這個地方，必須進行異常的處理，因為這里有可能有異常，有可能沒異常，那么，為了保證程序的正確運行，就必須進行異常的處理。
class Math{
public int div(int i,int j) throws Exception{ // 定義除法操作，如果有異常，則交給被調用處處理
int temp = i / j ; // 計算，但是此處有可能出現異常
return temp ;
}
};
public class ThrowsDemo02{
public static void main(String args[]){
Math m = new Math() ; // 實例化Math類對象
try{
System.out.println("除法操作：" + m.div(10,0));
}catch(Exception e){
e.printStackTrance();
}
}
};
這樣一來，就不會有問題了。
如果，這樣的操作呢，在主方法中再使用throws關鍵字聲明，主方法也不處理任何的異常，會不會有問題？
class Math{
public int div(int i,int j) throws Exception{ // 定義除法操作，如果有異常，則交給被調用處處理
int temp = i / j ; // 計算，但是此處有可能出現異常
return temp ;
}
};
public class ThrowsDemo02{
// 在主方法中的所有異常都可以不使用try...catch進行處理
public static void main(String args[]) throws Exception{
Math m = new Math() ; // 實例化Math類對象
System.out.println("除法操作：" + m.div(10,2)) ;
}
};
編譯運行，
這也是沒問題的
如果出現了異常的時候
class Math{
public int div(int i,int j) throws Exception{ // 定義除法操作，如果有異常，則交給被調用處處理
int temp = i / j ; // 計算，但是此處有可能出現異常
return temp ;
}
};
public class ThrowsDemo02{
// 在主方法中的所有異常都可以不使用try...catch進行處理
public static void main(String args[]) throws Exception{
Math m = new Math() ; // 實例化Math類對象
System.out.println("除法操作：" + m.div(10,0)) ;
}
};
似乎和沒有使用異常處理的時候，打印出的是一個造型。
那么問題又來了，
主方法都沒有處理這異常，那異常到哪里去了呢，誰去處理這個異常了呢？難道是jvm么？
是的，其實就是jvm，在主程序中不處理任何的異常了，而是交給了它的上級，最大的頭，Java中最大的頭，就是jvm，所以，如果在主方法中使用了throws關鍵字，則表示一切的異常都交給jvm去處理，其實，Java默認的異常處理也是使用jvm完成的。
6，throw關鍵字
throw關鍵字的作用是在程序中拋出一個異常，拋出的是一個異常類的實例化對象。
使用了throw，拋出了異常，必然要進行捕獲和處理，就是說，必須要進行try-catch處理。
在異常的處理中，try語句是捕獲異常，它捕獲的其實是一個異常類對象，那么此異常對象也可以自己拋出。
怎么個意思呢？
查找一下Java-doc看看exception的構造，發現，可以傳入一個String的message。
public class ThrowDemo01{
public static void main(String args[]){
try{
throw new Exception("自己拋著玩的。") ; // 拋出異常的實例化對象
}catch(Exception e){
System.out.println(e) ;
}
}
};
如果不進行捕獲和處理這個拋出的異常，編譯都不會通過：
public class ThrowDemo01{
public static void main(String args[]){
throw new Exception("自己拋著玩的。") ;
}
};
在一般的開發中，try-catch-finally，throws，throw聯合使用是最多的。
比如，這樣的需求：現在對于兩個數的除法這個操作，要求，產生異常在方法調用處去處理異常，在計算前打印“開始計算”，在計算結束后，無論是否出現異常都打印“計算結束”，如果出現異常打印出異常信息，如果沒有異常當然得打印出計算結果。
class Math{
public int div(int i,int j) throws Exception{ // 定義除法操作，如果有異常，則交給被調用處處理
System.out.println("***** 計算開始 *****") ;
int temp = 0 ; // 定義局部變量
try{
temp = i / j ; // 計算，但是此處有可能出現異常
}catch(Exception e){
throw e ;
}finally{ // 不管是否有異常，都要執行統一出口
System.out.println("***** 計算結束 *****") ;
}
return temp ;
}
};
public class ThrowDemo02{
public static void main(String args[]){
Math m = new Math() ;
try{
System.out.println("除法操作：" + m.div(10,0)) ;
}catch(Exception e){
System.out.println("異常產生：" + e) ;
}
}
};
7，Exception和RunntimeException的區別
先看看什么是RunntimeException，查看API，抓一個方法出來瞧瞧：
public static int parseInt(String s)
throws NumberFormatException
Parses the string argument as a signed decimal integer. The characters in the string must all be decimal digits, except that the first character may be an ASCII minus sign '-' ('\u002D') to indicate a negative value or an ASCII plus sign '+' ('\u002B') to indicate a positive value. The resulting integer value is returned, exactly as if the argument and the radix 10 were given as arguments to the parseInt(java.lang.String, int) method.
Parameters:
Returns:
the integer value represented by the argument in decimal.
Throws:
NumberFormatException - if the string does not contain a parsable integer.
主人，問題tm又來了
public class RuntimeExceptionDemo01{
public static void main(String args[]){
String str = "123" ; // 定義字符串，全部由數字組成
int temp = Integer.parseInt(str) ; // 將字符串變為int類型
System.out.println(temp * temp) ; // 計算乘方
}
};
可以看到這個方法，命名使用了throws修飾，需要在方法的調用處處理異常，為什么我們可以直接使用，而沒有去處理異常，也沒有編譯報錯呢？
分析一下，這是為什么呢？我們先看看這個NumberFormatException，看看它的繼承結構：
可以發現，這個NumberFormatException異常是RunnTimeException的子類，
Exception和RunntimeException的區別：
①，Exception在程序中必須進行try-catch處理。
②，RunntimeException可以不使用try-catch處理，但是如果有異常產生，則異常將由jvm進行處理。
在Java的異常處理機制中，如果是Exception異常，則必須進行try-catch處理，如果是RunntimeException則不是必須進行try-catch進行處理的，但是為了保證程序的健康性，在有可能出現異常的地方，其實還是進行異常處理比較好。
8，自定義異常類
其實，只需要繼承Exception就可以自定義一個自己需要的異常類了，當然繼承RunntimeException也是可以的。
class MyException extends Exception{ // 自定義異常類，繼承Exception類
public MyException(String msg){
super(msg) ; // 調用Exception類中有一個參數的構造方法，傳遞錯誤信息
}
};
public class DefaultException{
public static void main(String args[]){
try{
throw new MyException("自定義異常。") ; // 拋出異常
}catch(Exception e){
System.out.println(e) ;
}
}
}
9，斷言
什么是斷言？
就是肯定某一個操作的返回結果是正確的，如果程序執行到斷言語句的時候，發現斷言不正確了，返回結果是錯誤的了，則通過斷言檢查肯定，會為用戶提示錯誤的信息。
斷言的使用格式：
assert boolean 表達式；
assert boolean 表達式：詳細信息；
public class Test{
public static void main(String args[]){
int x[] = {1,2,3} ; // 定義數組，長度為3
assert x.length==0 ; // 此處斷言數組的長度為0
}
};
斷言本身不會影響程序的執行，如果要想要斷言起作用，則必須對斷言進行驗證
enableassertions可以簡寫為ea，
驗證：
發現驗證斷言驗證失敗了。
如果斷言驗證是成功的，
斷言，也可以自己設置錯誤信息：
public class Test{
public static void main(String args[]){
int x[] = {1,2,3} ; // 定義數組，長度為3
assert x.length==0 : "數組長度不為0" ; // 此處斷言數組的長度為0
}
};
再進行斷言的驗證：
1，在實際開發中，斷言用的并不多。
2，throw是拋出異常；
3，throws是方法聲明出使用，表示此方法不處理異常，而是在方法調用處處理此異常；
4，Exception異常是必須處理的，RunntimeException異常不是必須進行處理的，但是為了保證程序的正常運行，最好有異常產生就對其進行處理。
5，如果需要自定義異常，則只需要直接繼承Exception或者RunntimeException即可。
總結
以上是生活随笔為你收集整理的java怎么捕捉除数异常_Java异常的捕获及处理---小总结的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 印钞机 java c c vb_自己动
- 下一篇： java学绘图吗_Java绘图