第一：return语句并不是函数的最终出口，如果有finally语句，这在return之后还会执行finally（return的值会暂存在栈里面，等待finally执行后再返回）

第二：finally里面不建议放return语句，根据需要，return语句可以放在try和catch里面和函数的最后。可行的做法有四：

1.return语句只在函数最后出现一次。

2.return语句仅在try和catch里面都出现。

3.return语句仅在try和函数的最后都出现。

4.return语句仅在catch和函数的最后都出现。

注意，除此之外的其他做法都是不可行的，编译器会报错。

 

（1）如果程序运行到try成功时可以返回结果，则采用方法2。（见下面的例子test0_1，在那个例子中，方法2和4都是可行的，但是推荐方法2？）

（2）如果程序运行到catch时（即中途出错时）无需再继续执行后面的代码了，则采取方法4；（见下面例子中的test0，在那个特殊的例子中，只能采取方法4）

（3）如果程序运行到try或catch时还需要继续执行后面的代码，则采取方法1（见下面的例子test0_2，该例子只能采用方法1）。

 

下面是测试代码：

 

[java]  view plain  copy
 print ?
  1. public class Test {  
  2.   
  3.     public static void main(String[] args) {  
  4.         System.out.println("=============test1==================");  
  5.         System.out.println(test1());  
  6.         System.out.println("===============================");  
  7.   
  8.         System.out.println("=============test1_1==================");  
  9.         System.out.println(test1_1());  
  10.         System.out.println("===============================");  
  11.   
  12.         System.out.println("\n============test2===================");  
  13.         System.out.println(test2());  
  14.         System.out.println("===============================");  
  15.   
  16.         System.out.println("\n============test2_1===================");  
  17.         System.out.println(test2_1());  
  18.         System.out.println("===============================");  
  19.   
  20.         System.out.println("\n============test3===================");  
  21.         System.out.println(test3());  
  22.         System.out.println("===============================");  
  23.   
  24.         System.out.println("\n============test3_1===================");  
  25.         System.out.println(test3_1());  
  26.         System.out.println("===============================");  
  27.     }  
  28.   
  29.     public static String test0() {  
  30.         String a;  
  31.         int b;  
  32.         try{  
  33.             b = 8/0;  
  34.         }catch(Exception e){  
  35.             return null;  
  36.         }  
  37.         a = String.valueOf(b);  
  38.         return a+b;  
  39.     }  
  40.     
  41.     public static String test0_1() {  
  42.         String a;  
  43.         int b;  
  44.         try{  
  45.             b = 8/0;  
  46.             a = String.valueOf(b);  
  47.             return a+b;  
  48.         }catch(Exception e){  
  49.             return null;  
  50.         }  
  51.         //return a+b;  
  52.     }  
  53.       
  54.     public static String test0_2() {  
  55.         String a;  
  56.         int b=0;  
  57.         try{  
  58.             b = 8/0;  
  59.         }catch(Exception e){  
  60.         }  
  61.         a = String.valueOf(b);  
  62.         return a;  
  63.     }  
  64.       
  65.     public static String test1() {  
  66.         String a = "in try";  
  67.         int n = -1;  
  68.         try{  
  69.             return a+n; //先执行这个，再执行finally  
  70.         } catch ( Exception e ) {  
  71.   
  72.         } finally {  
  73.             //对String和int的更改均无效  
  74.             a = "in finally";  
  75.             n = 123;  
  76.             System.out.println("do finally");  
  77.         }  
  78.         return a; //不会执行  
  79.     }  //总结出一点：return语句并不是函数的最终出口，如果有finally语句，这在return之后还会执行finally  
  80.   
  81.     public static String test1_1() {  
  82.         String a = "in try";  
  83.   
  84.         try{  
  85.             return a;  
  86.         } catch ( Exception e ) {  
  87.   
  88.         } finally { //从eclpise报警告可看出，finally里面不建议有return语句  
  89.             a = "in finally";  
  90.             System.out.println("do finally");  
  91.             return a; //注释掉这句，eclipse将不再警告  
  92.         }  
  93.     }  
  94.   
  95.     public static int test2() {  
  96.         int a = 1;  
  97.   
  98.         try{  
  99.             return a;  
  100.         } catch ( Exception e ) {  
  101.   
  102.         } finally {  
  103.             a = 2;  
  104.             System.out.println("do finally");  
  105.         }  
  106.   
  107.         return a;  
  108.     } //很显然，finally里面更改无效，返回的是a=1  
  109.   
  110.     public static int test2_1() {  
  111.         int a = 1;  
  112.   
  113.         try{  
  114.             return a;  
  115.         } catch ( Exception e ) {  
  116.   
  117.         } finally {  
  118.             a = 2;  
  119.             System.out.println("do finally");  
  120.             return a;  
  121.         }  
  122.     } //很显然，a取finally里面的值，a=2  
  123.   
  124.     //Helper类，将整数转换成字符串  
  125.     static class Helper {  
  126.         int a;  
  127.   
  128.         public String toString() {  
  129.             return String.valueOf(a);  
  130.         }  
  131.     }  
  132.       
  133.     public static Helper test3() {  
  134.         Helper h = new Helper();  
  135.         h.a = 1;  
  136.   
  137.         try{  
  138.             return h;  
  139.         } catch ( Exception e ) {  
  140.   
  141.         } finally {  
  142.             h.a = 2; //对h.a的更改起作用!!  
  143.                     //因为在try里面返回的是一个句柄，它指向的对象的内容 是可以改变的  
  144.             System.out.println("do finally");  
  145.         }  
  146.           
  147.         return h; //这个不会被执行  
  148.     }  
  149.   
  150.     public static Helper test3_1() {  
  151.         Helper h = new Helper();  
  152.         h.a = 1;  
  153.   
  154.         try{  
  155.             return h;  
  156.         } catch ( Exception e ) {  
  157.   
  158.         } finally {  
  159.             h.a = 2; //返回a=2，这个不用说了  
  160.             System.out.println("do finally");  
  161.             return h;  
  162.         }  
  163.     }  
  164.   
  165.   
  166.     /** 
  167.      * 总结： 
  168.      * return语句，finally里面不建议放return语句，根据需要，可以放在try和catch里面 
  169.      *  
  170.      */  
  171.       
  172. }  


 异常处理之思考

    很少用自定义的异常类。

    因为对于一般的异常根本无需进行多么复杂的处理，所以用不着自定义的异常类）。如果有自定义的异常类，一般当场就catch掉而不抛出（抛出意味着什么？抛出一般会涉及到一个向上转型的过程，比如，为了能处理所有的异常，通常throws　Exception，这样就会把所有的异常子类都向上转型为Exception父类，就失去了自定义异常类的意义）。

    但是实际上，对于异常，尽量做抛出处理，这样可以减少程序中到处都是try-catch。使用try-catch捕获异常时，建议一个try只放一行可能出现异常的代码，不要把很多无关的代码都写在try中（这是从编程的逻辑上而言，当多个异常集中在一起时，不妨只用一个try-catch。因为这样可以提高程序的效率，毕竟系统每处理一个try-catch语句都会有比较大的开销）