java —— 异常中的陷阱

Posted 2020-10-23 Tiger Expensive

一、使用 finally 正确关闭资源的方式

　　finally 块无论程序是否异常总是会被执行，因此常用来关闭物理资源，从而保证资源总能被关闭。

import java.io.*;

public class CloseResource {

//一个函数同时读取两个文件

public void readTwoFile() throws FileNotFoundException, IOException{

    BufferedReader br1 = null;

    BufferedReader br2 = null;

    FileReader fr = null;

    try{

        fr = new FileReader("A.txt"); //1

        br1 = new BufferedReader(fr); 

        int count = br1.read();    //2

        //process code1....

        fr = new FileReader("B.txt"); //3

        br2 = new BufferedReader(fr);

        count = br2.read(); //4

        //process code2

    }finally{

        if(br1 != null){
            
            try {
                br1.close(); //5
            } catch (Exception e) {
                e.printStackTrace();
            }
            
        }
        if(br2 != null){
            
             try {
                br2.close(); //6
            } catch (Exception e) {
                e.printStackTrace();
            }  
        }    
    }
}

　　这样的关闭方式更加安全保证了，使用 finally 块来关闭物理资源，保证关闭操作总是会被执行； 关闭每个资源之前首先保证引用该资源的引用变量不为 null ； 为每个物理资源使用单独 try...catch 块关闭资源，保证关闭资源时引发的异常不会影响其他资源的关闭。

二、finally 与 return 

代码1：

public class TestDemo {
    /**
     *     count=5
     *  int i =++count ; 先加1后赋值给i --> 6
     *  int i =count++ ; 先赋值给i再加1 --> 5
     * @return
     */
    public static int test(){
        int count = 5;
        try{
            //有finally块，不会立即 return 
            //finally 有return ，这里的return 不执行
            return ++count; 
        } finally{
            System.out.println("---finally----"+count);
            return count++;
        }
    
    }

    public static void main(String args[]) {
        
        System.out.println(test());
    }
}
    "输出结果："
    ---finally----6
        6

　　当Java 程序执行try 块、catch 块时遇到了return 语句，return 语句会导致该方法立即结束。

　　上述代码，系统执行完return 语句之后，并不会立即结束该方法，而是去寻找该异常处理流程中是否包含finally 块，如果没有finally 块，方法终止，返回相应的返回值。如果有finally 块，系统立即开始执行finally 块——只有当finally 块执行完成后，系统才会再次跳回来根据return 语句结束方法。如果finally 块里使用了return 语句来导致方法结束，则finally 块已经结束了方法，系统将不会跳回去执行 try 块、 catch 块里的任何代码。

代码2：

class Test {
    public int test() {
        int x = 1;

        try {
            return ++x;
        } catch (Exception e) {

        } finally {
            ++x;
        }
        return x;
    }

    public static void main(String[] args) {
        Test t = new Test();
        int y = t.test();
        System.out.println(y);
    }
}

　　输出结果： 2

如果try语句里有return，那么代码的行为如下：

1.如果有返回值，就把返回值保存到局部变量中

2.执行指令跳到finally语句里执行

3.执行完finally语句后，返回之前保存在局部变量表里的值 

　　注意：如果你在finally里也用了return语句，比如return ++x。那么y会是3。因为规范规定了，当try和finally里都有return时，会忽略try的return，而使用finally的return。

代码3：

public static int test() {
        int count = 5;
        try {

            throw new NullPointerException("异常报错");
        } finally {
            System.out.println("finally");
            return count;
        }
    }

    public static void main(String args[]) {
        System.out.println(test());
    }
    
    输出结果：
    finally
        5

　　当程序执行 try 块、 catch 块时遇到 throw 语句时， throw 语句会导致该方法立即结束，系统执行 throw 语句时并不会立即抛出异常给方法的调用者，而是去寻找该异常处理流程中是否包含 finally 块。如果没有 finally 块，程序立即抛出异常；如果有 finally 块，系统立即开始执行 finally 块——只有当 finally 块执行完成后，系统才会再次跳回来抛出异常。如果 finally 块里使用 return 语句来结束方法，系统将不会跳回去执行 try 块、 catch 块去抛出异常。