finally关键字的特点及其面试题
        A:finally用于释放资源，它的代码永远会执行。
            特殊情况：如果在执行到finally之前jvm退出了，比如System.exit(0)，则就不能执行了finally控制的语句体了。
        B:面试题
            a:final,finally,finalize的区别?
                final：最终的意思，可以修饰类、成员变量、成员方法
                    修饰类，类不能被继承。
                    修饰变量，变量是常量。
                    修饰方法，方法不能被重写。
                finally：是异常处理的一部分，用于释放资源。
                    一般来说，代码肯定会执行，特殊情况：如果在执行到finally之前jvm退出了，比如System.exit(0)，则就不能执行了finally控制的语句体了。
                finalize：是Object类的一个方法，用于垃圾回收。
            b:如果catch里面有return语句，请问finally里面的代码还会执行吗?
                如果会，请问是在return前，还是return后。
                会。前。(相对于最后一个能执行到的return语句来说)
                准确的说，应该是在中间。
        C:try...catch...finally...的格式变形
            a:try...catch...finally...
            b:try...catch
            c:try...catch...catch...
            d:try...catch...catch...catch...finally...
            e:try...finally...
                这种做法的目前是为了释放资源但是异常没有处理。

 1 package cn.itcast_07;
 2 
 3 import java.text.ParseException;
 4 import java.text.SimpleDateFormat;
 5 import java.util.Date;
 6 
 7 /*
 8  * finally:被finally控制的语句体一定会执行。
 9  *         注意：如果在执行到finally之前jvm退出了，比如System.exit(0)，则就不能执行了finally控制的语句体了。
10  * 
11  * A:格式
12  *         try...catch...finally...
13  * B:用于释放资源，在IO流操作和数据库操作中会见到。
14  */
15 public class FinallyDemo {
16     public static void main(String[] args) {
17         String s = "2014-11-20";
18         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
19 
20         Date d = null; // 局部变量，引用数据类型，需要初始化为null。为什么呢？按理说 d = sdf.parse(s); 这一句就可以初始化了啊？
21         try {
22             d = sdf.parse(s); // 编译期异常，因为编译的时候，我不知道try里面有什么语句(编译只检查语法)，只有运行的时候才知道try里面有什么，如果这句前面有一句抛出异常，则就不会执行到这一句了。d就不能初始化了。    
23         } catch (ParseException e) {
24             e.printStackTrace();
25             System.exit(0);
26         } finally {
27             System.out.println("这里的代码是可以执行的");
28         }
29 
30         System.out.println(d);
31     }
32 }

 1 package cn.itcast_07;
 2 
 3 /*
 4  * 面试题：
 5  * 1:final,finally和finalize的区别
 6  *         final：最终的意思，可以修饰类、成员变量、成员方法
 7  *             修饰类，类不能被继承。
 8  *             修饰变量，变量是常量。
 9  *             修饰方法，方法不能被重写。
10  *         finally：是异常处理的一部分，用于释放资源。
11  *             一般来说，代码肯定会执行，特殊情况：如果在执行到finally之前jvm退出了，比如System.exit(0)，则就不能执行了finally控制的语句体了。
12  *         finalize：是Object类的一个方法，用于垃圾回收。
13  * 
14  * 2:如果catch里面有return语句，请问finally里面的代码还会执行吗?
15  *       如果会，请问是在return前，还是return后。
16  *            会。前。(相对于最后一个能执行到的return语句来说)
17  *         准确的说，应该是在中间。
18  * 
19  * 3:try...catch...finally...的格式变形
20  *         A:try...catch...finally...
21  *         B:try...catch
22  *         C:try...catch...catch...
23  *         D:try...catch...catch...catch...finally...
24  *         E:try...finally...
25  *             这种做法的目前是为了释放资源但是异常没有处理。
26  */
27 public class FinallyDemo2 {
28     public static void main(String[] args) {
29         System.out.println(getInt());
30     }
31 
32     public static int getInt() {
33         int a = 10;
34         try {
35             System.out.println(a / 0);
36             a = 20;
37         } catch (ArithmeticException e) {
38             a = 30;
39             return a;
40             /*
41              * return a; 在程序执行到这一步的时候，这里不是return a; 而是return 30; 这个返回路径就形成了。
42              * 但是呢，它发现后面还有finally，所以继续执行finally的内容，a=40
43              * 再次回到以前的返回路径，继续走 return 30;
44              */
45         } finally {
46             a = 40;
47             // return a; // 如果这样结果就是40了。
48         }
49         
50         return a;
51     }
52 }