[改善Java代码]不要在finally块中处理返回值

在finally代码块中处理返回值,这是在面试题中经常出现的题目.但是在项目中绝对不能再finally代码块中出现return语句,这是因为这种处理方式非常容易产生"误解",会严重误导开发者.

 public class Client {
     public static void main(String[] args) {
         try {
             doStuff(-1);
             doStuff(100);
         } catch (Exception e) {
             System.out.println("这里是永远都不会到达的");
         }
     }

     public static int doStuff(int _p) throws Exception {
         try {
             if (_p < 0) {
                 throw new DataFormatException("数据格式错误");
             } else {
                 return _p;
             }
         } catch (Exception e) {
             //异常处理
             throw e;
         } finally {
             return -1;
         }
     }
 }

对于以上代码,有两个问题:

①main方法中的doStuff方法的返回值是什么?

②duStuff方法永远都不会抛出异常吗?

答案是:doStuff(-1)的值是-1. doStuff(100)的值也是-1.调用doStuff方法永远不会抛出异常,原因就在于我们再finally代码块中加入了return语句.而这会导致出现两个问题:

(1)覆盖了try代码中的return返回值.

当执行doStuff(-1)时,doStuff方法产生了DataFormatException异常,catch块在捕捉此异常后直接抛出,之后代码执行到finally代码块,就会重置返回值,结果就是-1了,也就是出现了先返回,再执行finally,再重置返回值的情况.

是不是可以定义一个变量,在finally中修改后再return呢?代码如下:

    public static int doStuff() {
        int a = 1;
        try {
            return a;
        } catch (Exception e) {

        } finally {
            //重新修改一下返回值
            a = -1;
        }

        return 0;
    }

该方法的返回值永远是1,而不会是-1或0,为什么不会执行到return 0 呢?原因是finally执行完毕后,该方法已经有返回值了,后续代码就不会再执行了.这都是源于异常代码块的处理方式,在代码中加上try代码块就标志着运行时会有一个Throwable线程监视着该方法的运行,若出现异常,则交给异常逻辑处理.

我们知道方法是在栈内存中运行的,并且会按照"先进后出"的原则执行,main方法调用了doStuff方法,则main方法在下层,doStuff在上层,当doStuff方法执行完,"return a"时,此方法的返回值已经确定是int类型了,(a变量的值,注意基本类型都是值拷贝,而不是引用),此后finally代码块再修改a的值已经与doStuff返回者没有任何关系了,因此该方法永远返回1.

继续追问:那是不是可以在finally代码块中修改引用类型的属性,以达到修改返回值的效果呢?代码如下:

 public class Client {

     public static void main(String[] args) {
         System.out.println(doStuff2().getName());
     }

     public static Student doStuff2() {
         Student person = new Student();
         person.setName("张三");
         try {
             return person;
         } catch (Exception e) {
         } finally {
             //重新修改一下返回值
             person.setName("李四");
         }
         person.setName("王五");
         return person;
     }
 }

 class Student{
     private String name;

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

 }

此方法的返回值永远都是name为李四的Student对象,原因是Student是一个引用对象,在try代码块中返回值是Student对象的地址,finally中再修改哪当然会是李四了.

(2)屏蔽异常

为什么命名把异常throw出去了,单main方法却捕捉不到呢?这是因为异常线程在监视到有异常发生时,就会登记当前异常的类型为DataFormatException,但是当执行器执行finally代码块时,则会重新为doStuff方法赋值,也就是告诉调用者,"该方法执行正确,没有产生异常,返回值是1" 于是乎异常神奇的消失了,其简化代码如下所示:

 public class Client {

     public static void doSomething() {
         try {
             //正常抛出异常
             throw new RuntimeException();
         } finally {
             //告诉JVM:该方法正常返回
             return;
         }
     }

     public static void main(String[] args) {
         try {
             doSomething();
         } catch (RuntimeException e) {
             System.out.println("这里永远都不会到达！");
         }
     }
 }

上面finally代码块中的return已经告诉JVM:doSomething方法正常执行结束,没有异常,所以main方法就不能获得任何的异常信息了,这样的代码会使得可读性大大降低,读者很难理解作者意图,增加了修改难度.

在fianlly中处理return返回值,代码看上去很完美,都不符合逻辑,但是执行起来就会产生逻辑错误,最重要的一点是finally是用来做异常收尾处理的.一旦加上return语句就会让程序的复杂度陡然提升.而且会产生一些隐蔽性非常高的错误.

与return相似,System.exit(0)或Runtime.getRuntime().exit(0)出现在异常代码块中也会产生非常多类似的错误假象....