java catch getm_Java------异常处理机制
一、什么是異常處理
異常處理從字面的意思來講就是一種發生在 java 程序中的錯誤并對其處理，但對程序員而言，異常的處理不單單的簡單去處理異常，就 ok 了，還有眾多的概念和使用異常的方式方法需要掌握
異常在 java 中分有三種：
1、編譯時異常(受檢異常)------> 這種異常發生的概率很高；
2、運行時異常 ------> 這種異常發生的概率較低，發生時直接退出 JVM；
3、錯誤(error)-----> 錯誤和異常是不同，錯誤其實是脫離了程序員控制的問題，錯誤在代碼中經常被忽略。比如內存溢出，在編譯過程也是發現不了的;
如上圖可以看出受檢異常與運行時異常都繼承于 Exception 類， 而?Exception 與 Error 繼承 Throwable 類，最終它們的父類都是 Object；
二、處理異常的方式有哪些
處理異常的方式有兩種：
1、throws ：在需要進行異常處理的方法體上加上 ，該方法體的異常將不會被本方法進行處理，如果誰調用該方法，則調用該方法的同時將異常一起調用。當然調用該方法的調用者可以進行處理該異常，也可以同樣使用拋出異常。
這樣的操作其實只是將異常交給了其他的程序處理，如果其他程序沒有能力進行處理，則將一直進行拋出，直到遇見一個能夠處理該異常的程序，并終止異常(該如何處理該異常呢？)；
通過一個程序來更深次的了解 throws 如何處理異常：
1 1 importjava.io.FileInputStream;2 2 importjava.io.FileNotFoundException;3 3
4 4 /**
5 5 * throws 的深層次理解6 6*/
7 7 public classTest17 {8 8
9 9 //public static void main(String[] args) throws FileNotFoundException{//當然這里也可以直接使用父類 Exception
10 10
11 11 public static void main(String[] args) throwsException{12 12
13 13 System.out.println("我是入口");14 14
15 15m1();16 16}17 17
18 18 public static void m1() throwsFileNotFoundException{19 19 //從m1 - m3 的調用可以看出 throws 處理機制是不對異常處理，只是拋出異常，誰調用該異常，誰處理，最終會流向哪里處理呢？
20 20
21 21 System.out.println("m1...start!");22 22 m2(); //m1() 也同樣出現了異常
23 23 System.out.println("m1...end!");24 24}25 25
26 26 public static void m2() throwsFileNotFoundException{27 27 //28 28
29 29 System.out.println("m2...start!");30 30 m3(); //從這個地方我們就可以看出了當 m2()進行調用 m3()時，m2() 方法體也出現需要處理的異常
31 31 //同樣的可以依照 m3() 方法進行處理
32 32
33 33 System.out.println("m2...end!");34 34}35 35
36 36 //public static void m3() throws NullPointerException{
37 37 //已經對該方法體進行了拋出異常的設置，為什么是無效的？
38 38 //NullPointerException 因為這個是一個空指針的異常，它不對 IO 流的異常進行處理
39 39
40 40 public static void m3() throwsFileNotFoundException {41 41 //FileNotFoundException 異常機制對 m3 起到了效果，主要因為 FileNotFoundException 繼承 IOException;
42 42
43 43 FileInputStream fis = new FileInputStream("E:\\jaa 作業室\\temp.java");44 44 //FileInputStream 是一個繼承了異?；绢惖?IO 流； 所以同樣在使用它的時候程序員就需要對它進行處理
45 45
46 46 System.out.println("m3...end!");47 47}48 48}49 49 /**看看如果讀取的路徑出現錯誤會發生什么結果吧50 50 * 我是入口51 51 * m1...start!52 52 * m2...start!53 53 * // 這里也出現一了一件有意思的事情：54 54 * // 每個方法體中只有在 異常 前的值被輸出，緊跟異常之后的值直接不被讀取了55 55 * // 從中得出一個結論： 一個方法中通過 throws 拋出的異常，在被調用時，調用者與被調用本身，異常之后的代碼將被執行中斷，不會輸出結果，異常前的值會進行輸出56 56 *57 57 *58 58 * Exception in thread "main" java.io.FileNotFoundException: E:\jaa 作業室\temp.java (系統找不到指定的路徑。)59 59 * // 這里就是異常的處理結果了： Exception in thread "main" java.io.FileNotFoundException: E:\jaa 作業室\temp.java (系統找不到指定的路徑。)60 60 * // 是不是發現奇妙的事情：各個方法體不斷的對異常拋出，最后在 main 方法中進行了異常處理，那為什么方法體中就不能處理，只能在 main 中處理呢？61 61 * // 其實 main 方法是主調方法，是一切程序的入口，方法體只有被 main 調用才能輸出結果，(當然后面還有一種方法可以在方法體中處理)而異常的處理其實62 62 * // 也不是在 main 方法中處理的，可以看到 main 方法體上也出現了拋出異常的設置， 其實在程序員不能看到的 JVM 中，程序將異常最終交給了63 63 * // FileNotFoundException 類處理該異常。64 64 *65 65 *66 66 * at java.base/java.io.FileInputStream.open0(Native Method)67 67 * at java.base/java.io.FileInputStream.open(FileInputStream.java:213)68 68 * at java.base/java.io.FileInputStream.(FileInputStream.java:155)69 69 * at java.base/java.io.FileInputStream.(FileInputStream.java:110)70 70 *71 71 * at Rview.Test17.m3(Test17.java:43)72 72 * at Rview.Test17.m2(Test17.java:30)73 73 * at Rview.Test17.m1(Test17.java:22)74 74 * at Rview.Test17.main(Test17.java:15)75 75 * // 這里表示的是異常出現的行號索引76 76*/
Throws 深層次理解
2、try...catch... ： 捕捉有可能發生異常的代碼，并將它處理，不會對異常拋出，只會終止異常的向后發展
通過一個程序來了解 try...catch... 如何處理異常：
1 1 importjava.io.FileInputStream;2 2 importjava.io.FileNotFoundException;3 3 importjava.io.FileOutputStream;4 4 importjava.io.IOException;5 5
6 6 /**
7 7 * try...catch... 的使用方法和重點8 8*/
9 9
10 10 //這是一個與 Test17 相同的程序，但我們需要對這個程序使用使用不同的異常處理機制
11 11
12 12 public classTest18 {13 13
14 14 public static voidmain(String[] args) {15 15
16 16m1();17 17}18 18
19 19 public static voidm1(){20 20
21 21 System.out.println("m1...start!");22 22m2();23 23 System.out.println("m1...end!");24 24}25 25
26 26 public static voidm2(){27 27
28 28 System.out.println("m2...start!");29 29m3();30 30 System.out.println("m2...end!");31 31}32 32
33 33
34 34
35 35 public static voidm3(){36 36
37 37
38 38 //try...catch... 的重點： 可以在發生異常點進行直接處理異常，當其他調用者調用時將不會發現該方法曾經有過異常的情況，同時也不會將異常感染
39 39 //給調用者，總之可以直接對異常直接處理
40 40
41 41 //try...catch...不僅僅只能對單個異常進行捕捉處理，同時可以對多個不同類型的異常進行處理
42 42 try{43 43 FileInputStream fis = new FileInputStream("E:\\java\\作業室\\temp.java");44 44 //try 中將可能發生異常的代碼段進行捕捉
45 45 fis.close(); //再次出現了一個異常，再處理
46 46
47 47 //以上代碼出現異常，直接進入 catch 分支，不對其后的代碼進行編譯；
48 48 System.out.println("hello ");49 49}50 50 catch (FileNotFoundException e/*必須要加變量名*/) { /*將捕捉到的異常進行處理*/
51 51
52 52 //e.printStackTrace();//顯示處理結果的方法
53 53
54 54 System.out.println("出現了異常，已經處理！！");55 55
56 56 }catch(IOException e){57 57 //已經進行了異常處理，為什么出現了錯誤？
58 58 //兩個 catch 對不同的異常進行了處理，但是，前一個 catch 的異常處理類是最高類 Exception，而后一個 catch 的異常處理類
59 59 //FileNotFoundException 是 Exception 的一個子類，所以在進行多次的 catch 異常處理時注意子類與父類的位置關系
60 60 //(子類在前、父類在后 或者 同時是子類)
61 61e.printStackTrace();62 62}63 63 //同樣要進行異常處理，這次我們將使用 try... catch... 的方式處理
64 64
65 65 System.out.println("m3...end!");66 66}67 67}68 68
69 69 /**output result:70 70 * m1...start!71 71 * m2...start!72 72 * m3...end!73 73 * // 奇妙的事情又發生了，使用 try... catch...的方式處理異常并不影響異常之后的代碼運行74 74 *75 75 * m2...end!76 76 * m1...end!77 77 *78 78 *79 79 * java.io.FileNotFoundException: E:\java\作業室\temp.java (系統找不到指定的路徑。)80 80 * // 這個結果的輸出靠 printStackTrace() 方法；81 81 *82 82 * at java.base/java.io.FileInputStream.open0(Native Method)83 83 * at java.base/java.io.FileInputStream.open(FileInputStream.java:213)84 84 * at java.base/java.io.FileInputStream.(FileInputStream.java:155)85 85 * at java.base/java.io.FileInputStream.(FileInputStream.java:110)86 86 *87 87 *88 88 * at Rview.Test18.m3(Test18.java:42)89 89 * at Rview.Test18.m2(Test18.java:30)90 90 * at Rview.Test18.m1(Test18.java:23)91 91 * at Rview.Test18.main(Test18.java:17)92 92 * // 同樣是異常出現所在的行號索引93 93*/
try...catch 處理方式
三、getMessage() 和 printStackTrace()
這是兩個都是命令行打印異常信息在程序中出錯的位置及原因，其兩者的區別在于：前者的簡單的打印出錯原因，后者是詳細的打印出錯的位置及原因，一起用一段程序了解一下吧
1 1 importjava.io.FileInputStream;2 2 importjava.io.FileNotFoundException;3 3
4 4 public classTest19 {5 5
6 6 public static voidmain(String[] args) {7 7
8 8m2();9 9}10 10
11 11 public static voidm2 (){12 12m3();13 13}14 14
15 15 public static voidm3(){16 16 try{17 17 FileInputStream fis = new FileInputStream("E:\\自考本科學習筆記\\英語\\基礎英語語法、English.一般現在時態.docx");18 18
19 19 }catch(FileNotFoundException e){20 20 //e.printStackTrace();
21 21 /*printStackTrace(); 方法的使用 將詳細的描述錯誤的原因和錯誤出現的位置22 22 java.io.FileNotFoundException: E:\自考本科學習筆記\英語\基礎英語語法、English.一般現在時態.docx (系統找不到指定的文件。)23 23 at java.base/java.io.FileInputStream.open0(Native Method)24 24 at java.base/java.io.FileInputStream.open(FileInputStream.java:213)25 25 at java.base/java.io.FileInputStream.(FileInputStream.java:155)26 26 at java.base/java.io.FileInputStream.(FileInputStream.java:110)27 27 at Rview.Test19.m3(Test19.java:19)28 28 at Rview.Test19.m2(Test19.java:14)29 29 at Rview.Test19.main(Test19.java:10)*/
30 30
31 31 String st =e.getMessage();32 32System.out.println(st);33 33 /*getMessage() 方法的使用，會簡單的描述錯誤的原因34 34 E:\自考本科學習筆記\英語\基礎英語語法、English.一般現在時態.docx (系統找不到指定的文件。)35 35*/
36 36
37 37 //System.out.println(e.getMessage()); 另一種寫法
38 38}39 39}40 40 }
getMessage 與 printStackTrace 使用
四、finally的使用
finally 關鍵字的使用： finally 是在catch之后添加使用，它的作用是無論 try...catch...是否執行，它一定會執行
1 1 importjava.io.FileInputStream;2 2 importjava.io.FileNotFoundException;3 3 importjava.io.IOException;4 4
5 5 /*finally 通常在什么情況下使用6 6 通常在流關閉的情況下使用，這樣可以保證關閉可以一定執行7 7*/
8 8
9 9 public classTest20 {10 10
11 11 public static voidmain(String[] args) {12 12 FileInputStream fis = null;13 13 try{14 14 fis = new FileInputStream("E:\\自考本科學習筆記\\英語\\基礎英語語法\\English.句子成分.docx");15 15
16 16 System.out.println("HelloWord!");17 17 String s = null;18 18s.toString();19 19
20 20 }catch(FileNotFoundException e) {21 21e.printStackTrace();22 22 } finally{23 23 try{24 24 if (null !=fis){25 25fis.close();26 26}27 27 }catch(IOException e){28 28e.printStackTrace();29 29}30 30}31 31}32 32 }
finally的使用
finally的面試題：
1 1 importjava.io.IOException;2 2
3 3 public classTest21 {4 4
5 5 public static voidmain(String[] args) {6 6 int result =m();7 7System.out.println(result);8 8 //output result: 100
9 9 /**為什么出現這種情況？ finally 難道沒有執行嗎？10 10 *11 11 * java程序有兩個亙古不變的原則： 1、 方法體中代碼必須遵循自上而下順序依次執行12 12 * 2、 return 語句一旦執行，整個方法必須結束13 13 *14 14 **/
15 15}16 16
17 17 public static intm(){18 18 int i = 100;19 19 try{20 20 returni;21 21 } finally{22 22 i++;23 23}24 24
25 25 /**
26 26 * 所以 該方法的底層程序執行的是這樣的程序27 27 * public static int m(){28 28 * int i = 100;29 29 * int j = i;30 30 * i ++;31 31 * return j;32 32 * }33 33 **/
34 34}35 35 }
finally 的面試題
細談 final、 finally、 finalize的區別
fiinal：?修飾符(關鍵字) 如果一個類被聲明為final,意味著它不能再派生新的子類，不能作為父類被繼承。因此一個類不能既被聲明為abstract，又被聲明為final的。將變量或方法聲明為final,可以保證他們使用中不被改變。被聲明為final的變量必須在聲明時給定初值，而以后的引用中只能讀取，不可修改，被聲明為final的方法也同樣只能使用，不能重載。與 static? 連用將變量變為常量；
finally:在異常處理時提供 finally 塊來執行清楚操作。如果拋出一個異常，那么相匹配的 catch 語句就會執行，然后控制就會進入finally塊；
finalize：是方法名。java 技術允許使用 finalize() 方法在垃圾收集器將對象從內存中清除之前做必要的清理工作。這個方法是在垃圾收集器在確定了被清理對象沒有被引用的情況下調用的。finalize 是在Object 類中定義的，因此，所有的類都繼承了它。子類可以覆蓋 finalize() 方法，來整理系統資源或者執行其他清理工作。
四、運行時異常什么時候出現
程序在編譯階段是正常執行的，且沒有任何的錯誤，但是當運行時，就立馬出現了錯誤，并退出 JVM 這種情況在什么時候發生呢？
110 / 0 ---------> 這個就是一個很經典的運行時異常
總結
以上是生活随笔為你收集整理的java catch getm_Java------异常处理机制的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： java相对目录_java相对目录和绝对
- 下一篇： Java自定义配置文件xml_sprin