Java中try、catch、finally的使用

try、catch、finally语句块的作用

-》try 块：用于捕获异常

1、后面可以有0个或多个catch块

2、try块后面如果没有catch块，必须有一个finally块

3、执行代码捕获异常后进入catch块，try中出现异常代码处后面的代码不会再继续执行

-》catch 块：用于处理try捕获到的异常

1、可以有多个catch块

2、匹配到一个catch块后，其他catch块不会被执行

3、执行完毕后，如果有finally块，则进入finally块，finally之后的语句也继续执行

-》finally 块：无论是否捕获或处理异常，finally块里的语句都会被执行

1、当try块中或者catch块中遇到return语句时，先执行完finally中的代码，再执行return语句

2、如果有return语句，执行完finally后,  finally之后的语句不会再被执行

try、catch、finally语句块的执行顺序

public void try_catch_finally() {
    try {
        //代码a：代码执行区域
    } catch (Exception e1) {
        //代码b1：异常处理区域
    }catch (Exception e2) {
        //代码b2：异常处理区域
    }finally {
        //代码c：有无异常都需要执行的代码块
    }
    //代码d:其它内容
}

/**

 * 若代码a中无异常, 执行顺序为：a->c->d

 * 1、执行代码a

 * 2、代码a无异常，跳过catch

 * 3、执行finally部分(代码c)

 * 4、执行finally之后的代码(代码d)

 */

/**

 * 若代码a中有异常，捕获异常并处理异常：执行顺序为：a->b(b1或b2)->c->d

 * 1、执行代码a

 * 2、catch捕获异常，执行代码b(b1或b2)进行异常处理

 * 3、异常处理完成后，执行finally部分(代码c)

 * 4、执行finally之后的代码(代码d)

 */

总结：

1)当try没有捕获到异常时：try语句块的语句逐一执行，程序跳过catch语句块，执行finally语句块和其后的语句；

2)当try捕获到异常，catch语句块里有处理此异常的情况：在try语句块中是按照顺序来执行的，当执行到某一条语句出现异常时，程序将跳到catch语句块，并与catch语句块逐一匹配，找到与之对应的处理程序，其他的catch语句块将不会被执行，catch语句块执行完后，执行finally语句块里的语句。

3)若catch语句块里没有处理此异常的情况：此异常将会抛给JVM处理，finally语句块里的语句还是会被执行，但finally语句块后的语句不会被执行

return语句对执行顺序的影响

/**
 * try和catch有return 关键字时且没有finally时
 * 1、若try块没有捕获异常，执行return("try")
 * 2、若try块捕获异常，则执行return("catch");
 */
public String try_catch_finally() {
    try {
        return("try");
    } catch (Exception e) {
        return("catch");
    }
}

/**
 * try、catch有return关键字，finally无return
 * 1、若try没有捕获异常，执行return("try");
 * 2、若try捕获异常，也执行return("catch");
 */
public String try_catch_finally() {
    try {
        return("try");
    } catch (Exception e) {
        return("catch");
    } finally {
        System.out.print("finally");
    }
}

/**
 * try、catch、finally都有return关键字，无论是否捕获异常，都执行finally的return
 * 1、若try没有捕获异常，执行return ("finally");
 * 2、若try捕获异常，也执行return ("finally");
 */
public String try_catch_finally() {
    try {
        return("try");
    } catch (Exception e) {
        return("catch");
    } finally {
        return ("finally");
    }
}

/**
 *实例1： 以一个实例看下return语句的使用，执行完finallyReturn函数后，x,y,z变为11,20,31

 * 1、执行 try 代码块return ++x, 由于有finally语句，将x数据先放缓存区，
等执行完finally语句再返回，此时x=11
 
 * 2、没有捕获异常，不会执行 catch 代码块，y不变
 
 * 3、执行 finally 代码块，return ++z, 此时z=31
 
 * 4、finally的return语句会覆盖前面try的return ++x,所以最终return z的值(31)
 
 */
public class test {
    static int x = 10;
    static int y = 20;
    static int z = 30;
    public static void main(String[] args) {
        int finallyValue = finallyReturn();
        System.out.println("finallyValue=" + finallyValue); //31
        System.out.println("x=" + x); // 11
        System.out.println("y=" + y); // 20
        System.out.println("z=" + z);// 31
    }
    private static int finallyReturn() {
        try {
            return ++x;
        } catch (Exception e) {
            return ++y;
        } finally {
            return ++z;
        }
    }
}

/**
 * 实例2:执行finallyReturn函数后,value值为23和23134

 * 1、flag为true，执行throw new Exception()，然后由catch处理异常，
 * 然后执行finally(由于catch中有return,finally之后的语句不再执行)，此时value为23

 * 2、flag为false,没有异常跳过catch, 执行value+="1"，value+="3"，value+="4"; 
 * 此时value为23134

 */
import java.util.ArrayList;
public class test {
    public static String value="";
    public static void finallyReturn(boolean flag){
        try{
            if(flag){
                throw new Exception();
            }
            value+="1";
        } catch(Exception e){
            value+="2";
            return;
        }  finally{
            value+="3";
        }
        value+="4";
    }
    public static void main(String args[]){
        finallyReturn(true);
        System.out.println(value);//13423
        finallyReturn(false);
        System.out.println(value);//134
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
    }
}

finally不会执行的情况

1、try语句没有被执行到，如在try语句之前返回了，finally语句就不会执行

2、在try块中有System.exit(0)这样的语句，System.exit(0)将会终止Java虚拟机JVM，相当于整个程序停止