final、finally、finalize

一、final
1.定义变量，包括静态的和非静态的
用final修饰的变量（常量）比非final的变量（普通变量）拥有更高的效率，因此我们在实际编程中应该尽可能多的用常量来代替普通变量，这也是一个很好的编程习惯。
2.定义方法的参数
如果一个变量或方法参数被final修饰，就表示它只能被赋值一次，但是JAVA虚拟机为变量设定的默认值不记作一次赋值。
3.定义方法
它表示这个方法不可以被子类重写，但是它这不影响它被子类继承；
具有private访问权限的方法也可以增加final修饰，但是由于子类无法继承private方法，因此也无法重写它。编译器在处理private方法时，是按照final方法来对待的，这样可以提高该方法被调用时的效率。不过子类仍然可以定义同父类中的private方法具有同样结构的方法，但是这并不会产生重写的效果，而且它们之间也不存在必然联系。
4.定义类
final类不允许被继承，编译器在处理时把它的所有方法都当作final的，因此final类比普通类拥有更高的效率。final的类的所有方法都不能被重写，但这并不表示final的类的属性（变量）值也是不可改变的，要想做到final类的属性值不可改变，必须给它增加final修饰。
二、finally
用在try/catch语句中，并且附带着一个语句块，表示这段语句最终总是被执行。
1.测试return与finally

    public static int testReturn1() {
        int a = 1;
        try {
            System.out.println("a=" + a);
            return a++;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println("a=" + a + "，执行了finally语句");
            ++a;
            System.out.println("a=" + a);
        }
        return a;
    }

    public static int testReturn2() {
        int a = 1;
        try {
            System.out.println("a=" + a);
            return ++a;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println("a=" + a + "，执行了finally语句");
            ++a;
            System.out.println("a=" + a);
        }
        return a;
    }
    public static void main(String[] args) {
        System.out.println("测试return1-----------------");
        int a = FinallyUse.testReturn1();
        System.out.println("a=" + a);
        System.out.println("测试return2-----------------");
        a = FinallyUse.testReturn2();
        System.out.println("a=" + a);
    }

测试return1-----------------
a=1
a=2，执行了finally语句
a=3
a=1
测试return2-----------------
a=1
a=2，执行了finally语句
a=3
a=2

可以看出，finally虽然执行了，但是返回值a并没有因为执行了finally块而被改变返回值，说明返回值是在finally之前已经确定了。
2.测试continue与finally

    public static void testContinue() {
        for (int i = 0; i < 3; i++) {
            try {
                System.out.println("try内i=" + i);
                if (i == 1) {
                    continue;
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                System.out.println("finally内i=" + i + "，执行了finally语句");
                i++;
                System.out.println("finally内i=" + i);
            }
        }
    }

    public static void main(String[] args) {
        System.out.println("测试Continue-----------------");
        FinallyUse.testContinue();
    }

测试Continue-----------------
try内i=0
finally内i=0，执行了finally语句
finally内i=1
try内i=2
finally内i=2，执行了finally语句
finally内i=3

在循环中，finally中可以改变循环体的变量i，且每次continue之前都会执行finally
3.测试break与finally

    public static void testBreak() {
        int i = 0;
        for (; i < 3; i++) {
            try {
                System.out.println("try内i=" + i);
                if (i == 2) {
                    System.out.println("try内i=" + i+"，接下来执行break");
                    break;
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                System.out.println("finally内i=" + i + "，执行了finally语句");
                i++;
                System.out.println("finally内i=" + i);
            }
        }
        System.out.println("for外i=" + i);
    }
    public static void main(String[] args) {
        System.out.println("测试Break-----------------");
        FinallyUse.testBreak();
    }

测试Break-----------------
try内i=0
finally内i=0，执行了finally语句
finally内i=1
try内i=2
try内i=2，接下来执行break
finally内i=2，执行了finally语句
finally内i=3
for外i=3

在循环中，finally中可以改变变量i，且break之前执行finally

三、finalize
1.finalize()方法是在GC清理它所从属的对象时被调用的，如果执行它的过程中抛出了无法捕获的异常（uncaught exception），GC将终止对改对象的清理，并且该异常会被忽略；直到下一次GC开始清理这个对象时，它的finalize()会被再次调用。
2.没有提供finalize()方法的类，占用的堆内存更少，垃圾回收速度更快，而且JVM也不会创建那么多java.lang.ref.Finalizer对象。为什么有这么多的java.lang.ref.Finalizer对象对象呢？这是JVM内部的机制，用来保证finalize只被调用一次。实现了finalize()的对象，创建和回收的过程都更耗时。创建时，会新建一个额外的Finalizer 对象指向新创建的对象。 而回收时，至少需要经过两次GC。
3.Finalizer内部维护了一个unfinalized链表，每次创建的Finalizer对象都会插入到该链表中；如果类实现了finalize方法，进行GC的时候，如果发现某个对象只被java.lang.ref.Finalizer对象引用，那么会将该Finalizer对象加入到Finalizer类的引用队列（F-Queue）中，并从unfinalized链表中删除该结点。这个过程是JVM在GC的时候自动完成的。
4.含有finalize()的对象从内存中释放，至少需要两次GC。
第一次GC, 检测到对象只有被Finalizer引用，将这个对象放入 java.lang.ref.Finalizer.ReferenceQueue 此时，因为Finalizer的引用，对象还无法被GC。java.lang.ref.Finalizer$FinalizerThread 会不停的清理Queue的对象，remove掉当前元素，并执行对象的finalize方法。清理后对象没有任何引用，在下一次GC被回收。
5.Finalizer是JVM内部的守护线程，优先级很低。Finalizer线程是个单一职责的线程。这个线程会不停的循环等待java.lang.ref.Finalizer.ReferenceQueue中的新增对象。一旦Finalizer线程发现队列中出现了新的对象，它会弹出该对象，调用它的finalize()方法，将该引用从Finalizer类中移除，因此下次GC再执行的时候，这个Finalizer实例以及它引用的那个对象就可以回垃圾回收掉了。
6.使用finalize容易导致OOM内存耗尽，因为如果创建对象的速度很快，那么Finalizer线程的回收速度赶不上创建速度，就会导致内存垃圾越来越多

参考：http://bbs.youkuaiyun.com/topics/240068820
http://blog.youkuaiyun.com/aitangyong/article/details/39450341