浅谈 java中 final、finally 与 finalize的区别

1.final是java中的一个关键字，可以用来修饰类、方法、变量。

*修饰类：被fianl修饰的类不能派生出子类，因此一个类不能既被abstract修饰，又被final修 饰。 （需要注意final修饰的类中的所有成员方法都会隐式的定义为final方法）
*修饰方法：被final修饰的方法不能被重写。

*修饰变量： final修饰基本数据类型，表示该基本类型的值一旦被初始化就不能发生改变。
           final修饰引用数据类型，表示对其初始化后期地址引用不能发生变化，但是该地址引用所指向的对象的内容是可以变化的，例如：

                    final int a=4;
                    a=5;
                    此时就会报错。
                    而
                    final int[] array={1,2,3,4,5,6};
                    array[0]=9;
                    此时就不会报错。

           final 修饰成员变量，必须显示的初始化（不用final修饰时会有默认值）。一种是在变量申明时初始化；另一种是申明变量的时候不赋储值，而是在类的构造方法中对变量赋初值。

2.finally是try-catch处理异常的一部分，不管代码执行了try还是catch，都会执行finally。经常会用来释放资源。

例如：JDBC，java连接数据库中就用来在finally中释放资源                        
 package myjdbc;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;

import mypool.ConnectionPool;

public class SqlSession {
    //单例设计模式
    private SqlSession() {}
    private static SqlSession jdbc;
    public static synchronized SqlSession newInstance() {
        if(jdbc==null) {
            jdbc=new SqlSession();
        }
        return jdbc;
    }


    //获取连接池对象
    private ConnectionPool pool=ConnectionPool.newInstance();

    /**
     * 该方法用于实现任何一张表格的增删改
     * @param sql
     * @param obj
     */
    public void update(String sql,Object...obj) {
        Connection conn=null;
        PreparedStatement pstat=null;
        try {
            //获取连接
            conn=pool.getConnection();
            //获取静态常量
            pstat=conn.prepareStatement(sql);
            //通过
            for(int i=0;i<obj.length;i++) {
                pstat.setObject(i+1, obj[i]);
            }
            //执行操作
            pstat.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            try {
                pstat.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }

            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }


    public void insert(String sql,Object...obj) {
        this.update(sql, obj);
    }

    public void delete(String sql,Object...obj) {
        this.update(sql, obj);
    }


    /**
     * 该方法用于查询任何一个表格的一条记录
     * @param sql  
     * @param as  策略模式  是一个接口 
     * @param value  动态参数列表
     * @return   
     */
    public Object selectOne(String sql,Assignment as,Object...value) {
        Object obj=null;
        Connection conn=null;
        PreparedStatement pstat=null;
        ResultSet rs=null;
        try {
            conn=pool.getConnection();
            pstat=conn.prepareStatement(sql);
            for(int i=0;i<value.length;i++) {
                pstat.setObject(i+1, value[i]);
            }
            rs=pstat.executeQuery();
            if(rs.next()) {
                obj=as.assignment(rs);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            try {
                rs.close();
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
            try {
                pstat.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return obj;
    }




    public ArrayList<Object> selectList(String sql,Assignment as,Object...value) {
        ArrayList<Object> objList=new ArrayList<Object>();
        Connection conn=null;
        PreparedStatement pstat=null;
        ResultSet rs=null;
        try {
            conn=pool.getConnection();
            pstat=conn.prepareStatement(sql);
            for(int i=0;i<value.length;i++) {
                pstat.setObject(i+1, value[i]);
            }
            rs=pstat.executeQuery();
            while(rs.next()) {
                objList.add(as.assignment(rs));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            try {
                rs.close();
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
            try {
                pstat.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }

            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return objList;
    }
}

3.finalize是当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。子类重写 finalize 方法，以配置系统资源或执行其他清除。
Java 编程语言不保证哪个线程将调用某个给定对象的 finalize 方法。但可以保证在调用 finalize 时，调用 finalize 的线程将不会持有任何用户可见的同步锁定。如果 finalize 方法抛出未捕获的异常，那么该异常将被忽略，并且该对象的终结操作将终止。
在启用某个对象的 finalize 方法后，将不会执行进一步操作，直到 Java 虚拟机再次确定尚未终止的任何线程无法再通过任何方法访问此对象，其中包括由准备终止的其他对象或类执行的可能操作，在执行该操作时，对象可能被丢弃。
使用finalize还需要注意一个事，调用super.finalize();　一个对象的finalize()方法只会被调用一次，而且finalize()被调用不意味着gc会立即回收该对象，所以有可能调用finalize()后，该对象又不需要被回收了，然后到了真正要被回收的时候，因为前面调用过一次，所以不会调用finalize()，产生问题。 所以，推荐不要使用finalize()方法，它跟析构函数不一样。