final、finalize()、finally、static

一、final

final的三种情况：

1.变量

　　1）对于基本类型，final使数值恒定不变；而对于对象引用，final使引用恒定不变，即一旦引用被初始化指向一个对象，就无法再把它改为指向另一个对象，然而，对象自身却是可以被修改的。

　　2）被final修饰的变量是编译期常量。

     public static void main(String[] args) {
         String s = "sc";
         String a = "s";
         final String b = "s";
         String d = a + "c";
         String e = b + "c";
         System.out.println(d == s);//false
         System.out.println(e == s);//true
     }

分析：

在被使用final修饰的基本数据类型和String的时候，编译器会把它作为编译期常量使用，也就是在编译的时候b就已经作为常量赋值给e了，所以e的值就是一个常量“sc”。

而d则是在运行期间进行的赋值操作，将对象a赋值给d，虽然他们的值相同，但是他们的对象指针指向已经不相同了，s是在常量池中，而我们的d已经指向生成对象d的指针去了。

2.方法

1）把方法锁定，任何继承类都没法修改，也就是无法重写。

2）“重写”只在某方法是基类的接口的一部分时才会出现，即，必须能将一个对象向上转型为它的基本类型并调用相同的方法。如果某方法为private，它就不是基类的接口的一部分。它仅是一些隐藏于类中的程序代码，只不过是具有相同的名称而已。而父类中的public、protected或包访问权限的方法是不允许被子类重写的，也就是子类中不能有相同名字的方法。例子如下：

 class WithFinals {
     private final void f();
     public final void g();
 }
 class Son extends WithFinals {
     private final void f();
     public final void g();//出错，不允许
 }

3.类

1）不允许该类被继承。

 总结：

1）对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。

2）final方法不能被重写。

3）final类不能被继承。

二、finalize()

finalize()：gc准备释放内存时，会先调用finalize()。

finalize()的主要用途：回收特殊渠道申请的内存。比如JNI调用non-java程序，finalize()会回收这部分内存。

注意点：

1）finalize()不能保证会被及时执行。

2）垃圾回收只与内存有关。

3）垃圾回收和finalize()在内存还没耗尽时，是不会进行回收的。

4）finalize()线程的优先级比普通线程要低。

如果类的对象中封装的资源确实需要钟执，可以提供一个显式的终止方法，该方法通常与try-finally结合起来使用，以确保及时终止。

具体可以查看<<effective java>>中的第6条。

三、finally

结论：

1、无论在什么情况下，finally块中代码都会执行。
2、finally是在return后面的表达式运算完成后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，然后执行finally语句块，如果finally中有return，则返回的值会被改变）。

举例：

 情况1：try{} catch(){}finally{} return;
 显然程序按顺序执行。

 情况2:try{ return; }catch(){} finally{} return;
 程序执行try块中return之前（包括return语句中的表达式运算）代码；
 再执行finally块，最后执行try中return;
 finally块之后的语句return，因为程序在try中已经return所以不再执行。

 情况3:try{ } catch(){return;} finally{} return;
 程序先执行try，如果遇到异常执行catch块，
 有异常：则执行catch中return之前（包括return语句中的表达式运算）代码，再执行finally语句中全部代码，
 最后执行catch块中return. finally之后也就是4处的代码不再执行。
 无异常：执行完try再finally再return.

 情况4:try{ return; }catch(){} finally{return;}
 程序执行try块中return之前（包括return语句中的表达式运算）代码；
 再执行finally块，因为finally块中有return所以提前退出。

 情况5:try{} catch(){return;}finally{return;}
 程序执行catch块中return之前（包括return语句中的表达式运算）代码；
 再执行finally块，因为finally块中有return所以提前退出。

 情况6:try{ return;}catch(){return;} finally{return;}
 程序执行try块中return之前（包括return语句中的表达式运算）代码；
 有异常：执行catch块中return之前（包括return语句中的表达式运算）代码；
 则再执行finally块，因为finally块中有return所以提前退出。
 无异常：则再执行finally块，因为finally块中有return所以提前退出。

 最终结论：任何执行try 或者catch中的return语句之前，都会先执行finally语句，如果finally存在的话。
 如果finally中有return语句，那么程序就return了，所以finally中的return是一定会被return的，
 编译器把finally中的return实现为一个warning。

Exception（异常） 
是程序本身可以处理的异常。主要包含RuntimeException等运行时异常和IOException，SQLException等非运行时异常。 
运行时异常 包括：都是RuntimeException类及其子类异常，如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。 
运行时异常的特点是Java编译器不会检查它，也就是说，当程序中可能出现这类异常，即使没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译通过。 
非运行时异常（编译异常） 包括：RuntimeException以外的异常，类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常，一般情况下不自定义检查异常

程序运行时异常由Java虚拟机自动进行处理。捕获到的异常不仅可以在当前方法中处理，还可以将异常抛给调用它的上一级方法来处理。

捕获异常时，先捕获子类异常，再捕获父类异常。

四、static

1.static方法中不能直接处理非static变量，但可以通过对象调用处理，比如main方法。

2.static方法不能被子类重写。

3.static代码块只在类第一次加载时初始化一次。

4.static方法无论是类调用还是对象调用，都是类调用其实，比如Test test = null;test.hello()编译通过，且正确运行，因为test.hello()相当于Test.hello()。而引用不同于指针，引用中既包含指向对象的指针、又包含指向类的指针，test中指向对象的指针确实为空，但指向Test的指针可不为空啊。