Java基础——详尽说明try-catch-finally的用法

问:Java异常处理机制,理解了吗?Java异常处理,真的掌握了吗?什么是自定义异常?catch体里遇到return 是怎么处理?finally 体里有return怎么处理?catch 和 finally 体里同时遇上 return 怎么办?几道例题,理清它们。

try catch语句

格式:(代码区如果有错误,就会返回到异常处理)

1 try{
2 
3 //代码区
4 
5 }catch(Exception e){
6 
7 //异常处理
8 
9 }

首先要清楚,异常有运行时异常和check异常:

运行异常不需要强制捕获,他们是RuntimeException的子类。check异常需要try、catch的异常处理。

可以调用API去查询一下,比如常见的RuntimException有IndexOUtOfBoundsException(索引过界)、NullpointerException(空指针异常)等。常见的check异常有IO异常、SQL异常、FileNotFoundException(日期转换异常)等。

严重的话,如果某个高频率访问的类没有try,出现异常会导致程序崩溃。而try则可以保证程序的正常运行下去,比如说:

1 try{
2 int i = 1/0;
3 }catch(Exception e){
4 .....
5 }

小到一个计算,如果除数为0,则会报错,如果没有try的话,程序直接挂掉。用try的话,则可以让程序运行下去,并且输出为什么出错!

try catch 是捕捉try部分的异常,当你没有try catch的时候,如果出现异常则程序报错,加上try catch,出现异常程序正常运行,只是把错误信息存储到Exception里,所以catch是用来提取异常信息的,你可以在Catch部分加上一句System.out.println(e.ToString());,如果出现异常可以把异常打印出来。

代码实例:

 1 public class TestEx1 {
 2     public int add(int a, int b) {
 3         return a + b;
 4     }
 5 
 6     public int dev(int a, int b) {
 7         int c = a / b;// 这里有隐患
 8         return c;
 9     }
10 
11     public static void main(String[] args) {
12         TestEx1 c = new TestEx1();
13         int result = c.add(4, 9);
14         System.out.println("求和的结果是" + result);
15         try { // 防患于未然
16             int result_chu = c.dev(90, 0);
17             System.out.println("除的结果是" + result_chu);
18         } catch (Exception e) {
19             System.out.println("出错啦~");
20 
21         }
22     }
23 }

 下面补充一下,今天做的几道例题。笔记在注释里面了,要记住。

例一:

 1 public class TestEx2 {
 2     public int add(int a, int b) {
 3         return a + b;
 4     }
 5 
 6     public int dev(int a, int b) throws Exception {
 7         int c = a + b;
 8         return c;
 9     }
10 
11     static void main(String[] args) {
12         TestEx2 c = new TestEx2();
13         int result = c.add(7, 9);
14         System.out.println("求和的结果是" + result);
15         try {
16             int result_chu = c.dev(90, 0);
17             System.out.println("除的结果是" + result_chu);
18         } catch (Exception e) {
19             e.printStackTrace();
20         }
21     }
22 }

例二:

1 public class TestEx3 {
2     public static void main(String[] args) throws Exception {
3         throw new Exception("我是扔着玩的");
4     }
5 }

例三:

 1 public class TestEx4 {
 2     public int add(int a, int b) {
 3         return a + b;
 4     }
 5 
 6     // 假设这个除法的除数和被除数都不能为零
 7     public int dev(int a, int b) throws Exception {
 8         if (a == 0) {
 9             throw new Exception("除数不能为零");
10         } else if (b == 0) {
11             throw new Exception("被除数也不能为零");
12         }
13         int c = a / b;
14         return c;
15     }
16 
17     public static void main(String[] args) {
18         TestEx4 t = new TestEx4();
19         int result_add=t.add(4,80);
20         System.out.println("结果是:" + result_add);
21         
22         try {
23             //int result_add=t.add(4,80);加法写在try-catch里面,将不能执行
24             int result = t.dev(0, 90);
25             System.out.println("结果是:" + result);
26             //System.out.println("结果是:" + result_add);加法写在try-catch里面,将不能执行
27         } catch (Exception e) {
28             e.printStackTrace();
29         }
30         
31         System.out.println("执行到这里就是完美了");
32     }
33 }

例四:

 1 import java.util.Date;
 2 
 3 //自定义异常:自定义一个类,继承字Eception类,附Eception 继承自Throwable
 4 public class TestEx5 extends Exception {
 5     /**
 6      * 
 7      */
 8     private static final long serialVersionUID = 1L;
 9     private String m;
10 
11     public TestEx5(String m) {
12         super();// 调用父类的构造函数,这是一个好的习惯。注意:s是小写的。
13         this.m = m;
14     }
15 
16     public void printErrorInfo() {
17         System.out.println("错误的信息:" + m + "\t" + new Date());
18     }
19 
20     public void log() {
21         System.out.println("信息已经写在日志上了");
22     }
23 
24     // 虚拟一个银行业务
25     public static class Bank { //要用static修饰一下,否则下面调用的时候,会提示“Bank类没有封闭实例访问类型”
26         /*
27          * Java里面static一般用来修饰成员变量或函数。
28          * 但有一种特殊用法是用static修饰内部类,普通类是不允许声明为静态的,只有内部类才可以。
29          * 被static修饰的内部类可以直接作为一个普通类来使用,而不需实例一个外部类。
30          * 
31          */
32         int money = 90000;
33 
34         public void saveMoney(int money) {
35             this.money += money;
36             System.out.println("业务办理成功" + "\t" + "存款为" + money + "元");
37         }
38 
39         /*
40          * 需求:设置为,每次取钱最多不能超过50000,超了就抛出异常
41          *  取钱后,余额不能低于2,如果低于2就抛出异常
42          */
43         public void getMoney(int money) throws TestEx5 {
44             if (money > 50000) {
45                 throw new TestEx5("取款金额最大不能超过50000");
46             } else if (this.money - money < 2) {
47                 throw new TestEx5("余额不足!");
48             } else {
49                 this.money -= money;
50                 System.out.println("业务办理成功,本次取款金额为" + money + "元");
51                 System.out.println("当前余额" + this.money + "元");
52             }
53         }
54     }
55 
56         public static void main(String[] args) {
57             Bank bank = new Bank();
58             bank.saveMoney(30000);
59             bank.saveMoney(20000);
60             try { // 取钱有界限,所以用try-catch把它包裹起来,并制定规约,超出就抛出异常
61                 bank.getMoney(20000);
62                 bank.getMoney(30000);
63                 bank.getMoney(20000);
64                 bank.getMoney(20000);
65                 bank.getMoney(200000);
66             } catch (TestEx5 e) {// 调用自己定义的超出异常
67                 e.log();
68                 e.printErrorInfo();
69                 e.printStackTrace();
70             }
71         }
72     }

结果:

例五:

 1 import java.io.FileWriter;
 2 import java.io.Writer;
 3 
 4 /*
 5  * 请说明一下finally、final、finalize三者的区别:
 6  *1.final:用来定义常量的关键字,修饰方法表示不能重写;修饰类表示不能继承;修饰变量表示值不能改变
 7  *2.finalize:是Object类提供的一个方法,在类被垃圾回收器回收的时候调用,system.gc();可以引起到垃圾回收的调用
 8  *3.finally:用于处理异常,表示代码出不出异常都要执行。(也有两种特殊的情况,会使得finally执行不到)
 9  */
10 public class TestEx6 {
11 public static void main(String[]args){
12     try{
13         Writer t=new FileWriter("c:/txt");//快捷键 ctrl+shift+o:直接引入导包
14         t.write("这是我用eclipse直接在c盘建立的一个文本");//注意这里不是Writer,没有r。
15         t.close();
16         /*
17          *关闭资源,Java本身不具备打开和关闭文件的功能,具备这个功能的往往是操作系统。关闭是个好习惯,如果不进行关闭,操作系统还将继续对他进行占有。
18          *这时再去试图打开或者删除此文件是不成功的。所用要用到.close();。
19          */
20         }catch(Exception e){
21             e.printStackTrace();
22         }
23     System.out.println("执行到这里就是胜利");
24 }
25 }

例六:

 1 import java.io.FileWriter;
 2 import java.io.IOException;
 3 import java.io.Writer;
 4 
 5 public class TestEx7 {
 6     /*
 7      * J2SE 提供的最后一个批注是 @SuppressWarnings。
 8      * 该批注的作用是给编译器一条指令,告诉它对被批注的代码元素内部的某些警告保持静默。
 9      * 
10      * @SuppressWarnings 批注允许您选择性地取消特定代码段(即,类或方法)中的警告。
11      * 其中的想法是当您看到警告时,您将调查它,如果您确定它不是问题,您就可以添加一个 @SuppressWarnings 批注,以使您不会再看到警告。
12      * 虽然它听起来似乎会屏蔽潜在的错误,但实际上它将提高代码安全性,因为它将防止您对警告无动于衷 — 您看到的每一个警告都将值得注意。
13      */
14 
15     public static void main(String[] args) {
16         Writer t = null;//這里定義了一個全局變量
17         try {
18 
19             t = new FileWriter("c:/1.txt");//上面定義了全局變量t,這里的Writer t=new FileWriter("c:/1.txt");中等號左邊的Writer要去掉。
20             t.write("这是加入的一个文本");// 注意这里不是Writer,没有r。
21         } catch (IOException e) {
22             // TODO Auto-generated catch block
23             e.printStackTrace();
24         } finally {// finally里面可以有try-catch语句
25             try {
26                 t.close();
27             } catch (IOException e) {
28                 // TODO Auto-generated catch block
29                 e.printStackTrace();
30             }
31         }
32         System.out.println("會執行到這里嗎?");
33     }
34 }

总结:

1.java的异常处理中,在不抛出异常的情况下,程序执行完try里面的代码块之后,该方法并不会立即结束,而是继续试图去寻找该方法有没有finally的代码块,如果没有finally代码块,整个方法在执行完try代码块后返回相应的值来结束整个方法。

2.值得注意的是,如果有finally代码块,此时程序执行到try代码块里的return语句之时并不会立即执行return,而是先去执行 finally 代码块里的代码,此时又分为两种情况,若 finally 代码块里没有return或没有能够终止程序的代码,程序将在执行完finally代码块代码之后再返回try代码块执行return语句来结束整个方法;若finally代码块里有return或含有能够终止程序的代码,方法将在执行完finally之后被结束,不再跳回 try 代码块执行 return。

3.finally里的语句只有两种情况下,会不被执行。一种是,在try-catch语句之前,程序就结束了或者挂掉了。第二种是遇到System.exit();

 

补充说明System.exit();的用法:

System是一个Java类,调用exit(0)方法终止虚拟机也就是退出你的Java程序,括号里面的是参数,进程结束的返回值。

查看Java.lang.System的源代码,我们可以找到System.exit(status)这个方法的说明,代码如下:

 1     /** 
 2        * Terminates the currently running Java Virtual Machine. The 
 3        * argument serves as a status code; by convention, a nonzero status 
 4        * code indicates abnormal termination. 
 5        * <p> 
 6        * This method calls the <code>exit</code> method in class 
 7        * <code>Runtime</code>. This method never returns normally. 
 8        * <p> 
 9        * The call <code>System.exit(n)</code> is effectively equivalent to 
10        * the call: 
11        * <blockquote><pre> 
12        * Runtime.getRuntime().exit(n) 
13        * </pre></blockquote> 
14        * 
15        * @param      status   exit status. 
16        * @throws  SecurityException 
17        *        if a security manager exists and its <code>checkExit</code> 
18        *        method doesn't allow exit with the specified status. 
19        * @see        java.lang.Runtime#exit(int) 
20        */  
21       public static void exit(int status) {  
22     untime.getRuntime().exit(status);  
23       }  

此方法是用来结束当前正在运行中的java虚拟机:

1.System.exit(0)是将整个虚拟机里的内容都停掉了 ;

2.dispose()只是关闭这个窗口,但是并没有停止整个application exit() ;

3.System.exit(0)是正常退出程序,而System.exit(1)或者说非0表示非正常退出程序;

4.System.exit(status)不管status为何值都会退出程序。和return 相比有以下不同点:return是回到上一层,而System.exit(status)是回到最上层。

posted @ 2017-06-19 23:51  江河湖泊  阅读(1662)  评论(0编辑  收藏  举报