try-catch-finally的使用

try-catch-finally语句与return联合使用、try-catch对程序性能的影响。我做了九个对比小实验进行研究，得到以下结论：
**1、finally语句在return语句执行之后return返回之前执行的。
2、finally块中的return语句会覆盖try块中的return返回。
3、如果finally语句中没有return语句覆盖返回值，那么原来的返回值可能因为finally里的修改而改变也可能不变。如果返回基本数据类型不会受finally中的修改影响，如果是返回引用类型会受finally中的修改影响。
4、try块里的return语句在异常的情况下不会被执行，这样具体返回哪个看情况。
5、当发生异常后，catch中的return执行情况与未发生异常时try中return的执行情况完全一样。
6、无异常时候，try-catch几乎不影响程序运行时间。
7、有异常的时候，异常类型匹配越精确越少时间开销。
8、不单纯的用Exception过滤异常、尽量少地在try里面添加代码、尽量不在循环里使用try-catch**
实验只是对try-catch-finally的初步认识，如果深入原理研究还需要研究程序字节码。
第一个问题：finally语句是否一定会执行？
答案：不一定
有两种情况：（1）try之前程序就返回了 （2）try之前程序出错，导致无法向下执行。
代码清单一：

package trycatchfinallyDEMO;
public class FinallyTest {
    static int test() {
       int i = 1;
       if (1 == i) {
           return 0; //first case
       }
       System.out.println("previous statement");
       // i /= 0; //second case
       try {
           System.out.println("try");
           return i;
       } finally {
           System.out.println("finally");
       }
    }

    public static void main(String[] args) {
       System.out.println("return value is:" + test());

    }

}

Output：
first case：return value is：0
second case：报错

以上两种情况，finally语句都没有得到执行。只有与finally相对应的try语句得到执行的时候finally才会执行。
第二个问题：try语句块得到执行的情况下，finally语句一定会得到执行？
答案：否定
代码清单二：

package trycatchfinallyDEMO;

public class FinallyTest {
    static int test() {
       int i = 1;
       System.out.println("previous statement");
       // i /= 0; //second case
       try {
           System.out.println("try");
           System.exit(0);
           return i;
       } finally {
           System.out.println("finally");
       }
    }

    public static void main(String[] args) {
       System.out.println("return value is:" + test());
    }
}

Output：
previous statement
try
当一个线程在执行 try 语句块或者 catch 语句块时被打断（interrupted）或者被终止（killed），与其相对应的 finally 语句块可能不会执行。还有更极端的情况，就是在线程运行 try 语句块或者 catch 语句块时，突然死机或者断电，finally 语句块肯定不会执行了。
第三个问题：多catch如何匹配捕获
答案：按代码书写顺序寻找最接近的异常进行匹配，找到之后不再进行查找。
代码清单三：

package trycatchfinallyDEMO;

public class myException extends Exception {
    public String toString(){
       return "This is myException!";
    }
}
package trycatchfinallyDEMO;

public class mulcatch {
    static void f() throws myException {
       System.out.println("throw a myException");
       throw new myException();
    }

    static void g() throws Exception {
       System.out.println("throw a Exception");
       throw new Exception();
    }

    public static void main(String[] args) {
       try {
           f();// f()抛出异常得到处理后，下面的输出和g()不会得到执行。
           System.out.println("**********************");
           g();
       } catch (myException e) {
           System.out.println("first catch get it");
       } catch (Exception e) {// Exception是基类，应该放在最后捕获，放在最一开始会出错。
           System.out.println("second catch get it");
       } finally {
           System.out.println("program is end");
       }

       System.out.println("--------------------------------");

       try {
           g(); // 会被最接近的异常类型捕获
           System.out.println("**********************");
           f();
       } catch (myException e) {
           System.out.println("first catch get it");
       } catch (Exception e) {//哪个catch捕获了异常就会由哪个catch处理，其他catch不执行
           System.out.println("second catch get it");
       } finally {
           System.out.println("program is end");
       }

    }
}

Output：
throw a myException
first catch get it
program is end

---

throw a Exception
second catch get it
program is end
注意：
1、try块中，抛出异常的语句之后的语句不会得到执行。
2、Catch顺序应该是由派生到基类，由小到大捕获，Exception应该最后捕获。
3、会被最接近的异常类型捕获，一旦异常被捕获，其他catch就不会被执行。

第四个问题：finally语句和return语句执行顺序
答案：finally语句在return语句执行之后返回之前执行
在这里系统的讨论下return在try-catch-finally各语句块中的情况。

情况1: try-catch 中的return
代码清单四：

package trycatchfinallyDEMO;

public class tryandcatchwithreturn {
    static int g(int i) {
       try {
           //i /= 0;//此处触发异常之后，就直接执行catch并返回，try里面剩下的语句不再执行。
           System.out.println("g()");
           return i;
       } catch (Exception e) {
           i += 3;
           return i;
       }
    }

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

}

Output：
g()
1
如果去掉注释输出就是4，如果注释catch当中的return就会报错，因为编译器认为try里面的return之前可能有异常产生，导致return得不到执行，所以要在函数finally或者函数尾部添加return,或者try-catch里同时添加return

情况2:try-finally中的return
代码清单五：

package trycatchfinallyDEMO;

public class tryandfinallywithreturn {
    static int g(int i) {
       try {
           i += 2;
           System.out.println("g()");
           return i;
       } catch (Exception e) {


       } finally {
           i += 5;
           System.out.println(i);
           //return i;
// finally里也有return，先執行try裏面的return并緩存，然后由于finally里面也有return，所以程序不再返回try进行return
           // 而是直接在finally进行return
       }
    }

    public static void main(String[] agrs) {

       System.out.println(g(1));
    }

}

Output：
g()
8
3
如果在finally中也添加return，那么输出为
g()
8
8
finally中无return时，程序会执行了try块中的return之后，缓存结果，然后执行finally块，最后返回缓存的结果，即使finally中对i进行了修改也没有不会反应到返回值中。如果finally里也有return的话，那么直接在finally里返回值，不在返回缓存结果。

情况3:try-catch-finally中都有return
代码清单六：

package trycatchfinallyDEMO;

public class trycatchfinallywithreturn {
    static int g(int i) {
       try {
           i /= 0;
           System.out.println("g()");
           return i;
       } catch (Exception e) {
           i += 3;
           System.out.println("catch:" + i);
           return i;
       } finally {
           i += 5;
           System.out.println("finally:" + i);
           //return i;//和try-catch中return的情况一样，会缓存catch当中的return，如果finally没有return则返回缓存中的i
           //如果finally中有return，则直接返回。
       }
    }

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

}

Output：
catch:4
finally:9
4
如果在finally中添加return，那么输出为
catch:4
finally:9
9
类似于try-catch中return的情况，会缓存catch当中的return，如果finally没有return则返回缓存中的i。如果finally中有return，则直接返回。
第五个问题：返回引用的情况下呢？
代码清单七：

package trycatchfinallyDEMO;

public class recommenddemo {
    static myClass myclass = new myClass();

    static myClass g() {
       try {
           myclass.setTip("world");
           return myclass;
       } catch (Exception e) {
           myclass.setTip("r u ok?");
           return myclass;
       } finally {
           myclass.setTip("tencent");
           //return myclass;
       }
    }

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

    }

}

Output：
hellotencent
可以看到即使finally中不进行return覆盖也会让finally块中操作反应到myclass
第六个问题：try-catch是否影响性能
情况1：不产生异常的时候
代码清单八：

package trycatchfinallyDEMO;

public class trycatchPerformance {

    public static void main(String[] args) {
       int result = 1;
       long starttime1 = System.nanoTime();
       for (int i = 0; i < 20; i++) {
           result *= i;
       }
       long endtime1 = System.nanoTime();
       System.out.println("不使用try-catch所用时间：" + (endtime1 - starttime1));
       result = 1;
       long starttime2 = System.nanoTime();
       try {
           for (int i = 0; i < 20; i++) {
              result *= i;
           }
       } catch (Exception e) {
           // TODO: handle exception
       }
       long endtime2 = System.nanoTime();
       System.out.println("使用try-catch所用時間：" + (endtime2 - starttime2));

    }

}

Output：
不使用try-catch所用时间：1555
使用try-catch所用時間：1556
实验表明在不产生异常的情况下，try-catch不会明显影响程序运行时间。
情况2：产生异常的时候
代码清单九：

package trycatchfinallyDEMO;

public class PerformanceWithEception {

    public static void main(String[] args) {
       int result = 1;
       long starttime1 = System.nanoTime();
       for (int i = 0; i < 20; i++) {
           result *= i;
       }
       long endtime1 = System.nanoTime();
       System.out.println("不使用try-catch所用时间：" + (endtime1 - starttime1));
       result = 1;
       long starttime2 = System.nanoTime();
       try {
           for (int i = 0; i < 20; i++) {
              result *= i;
           }
           throw new mysecondException();
       } catch (Exception e) {
           // TODO: handle exception
       }
       long endtime2 = System.nanoTime();
       System.out.println("使用try-catch Exception所用時間：" + (endtime2 - starttime2));

       long starttime3 = System.nanoTime();
       try {
           for (int i = 0; i < 20; i++) {
              result *= i;
           }
           throw new mysecondException();
       } catch (myException e) {
           // TODO: handle exception
       }catch (Exception e) {
           // TODO: handle exception
       }
       long endtime3 = System.nanoTime();
       System.out.println("使用try-catch myException所用時間：" + (endtime3 - starttime3));

       long starttime4 = System.nanoTime();
       try {
           for (int i = 0; i < 20; i++) {
              result *= i;
           }
           throw new mysecondException();
       } catch (mysecondException e) {
           // TODO: handle exception
       }catch (myException e) {
           // TODO: handle exception
       }
       catch (Exception e) {
           // TODO: handle exception
       }
       long endtime4 = System.nanoTime();
       System.out.println("使用try-catch mysecondException所用時間：" + (endtime4 - starttime4));

    }

}

Output：
不使用try-catch所用时间：622
使用try-catch Exception所用時間：22394
使用try-catch myException所用時間：2488
使用try-catch mysecondException所用時間：2177
由于多出对异常进行类型匹配以及相关处理操作，try-catch在有异常处理时，的确会消耗很多的运行时间。但是与不使用try-catch在时间上不具备可比性，因为它们是功能上的对比。
通过试验可知，catch到的异常类型越接近发生的异常越节省时间，如果单纯的用Exception去过滤会造成很大的时间开销。同时可以想到，尽量少地在try里面添加代码、尽量不在循环里使用try-catch、尽量精确地匹配异常等优化措施，从而提高性能。