最近在学习中遇到了final和finally,但是老是不知道他们的具体情况,对他们的感念总是太模糊,具体用的时候老是不知道用哪个

final ：最终 ，相关的使用说明

1、修饰符，可以修饰类、函数、变量。

2、被final修饰的类不可以被继承。（继承的弊端：打破了类的封装性）

3、被final修饰的函数是不可以被复写的。

4、被final修饰的变量是常量，只能赋值一次，既可以修饰局部变量，又可以修饰成员变量。

   当描述事物时，只能出现固定值，那么为了增强阅读性，都给这些变量取名字，因这个值不会改变，所以要

   加上final修饰。

   作为常量，其书写规范要求所有字母都大写，如果多单词组成，每个单子之间用_连接，如:

    final double MY_PI=3.14;

    public static final double MY_PI=3.14; //全局常量,通过类名访问

5、内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。

finally:
finally 关键字是对 Java 异常处理模型的最佳补充。 finally 结构使代码总会执行，而不管有无异常发生。

final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。被final修饰就是最终的
finally一般用于异常处理try{}catch(){}finall{}...就最后finally一定会执行...为了安全性一般用于发生异常关闭资源.

1楼讲的很详细，我也学习了。
另外，补充一小点：
final修饰类后，其中的方法是final的，变量不是。
[我记得应该是这样的，如果说错，请指正，呵呵]

final—修饰符（关键字），如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的方法只能使用，不能重载。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改，这里是指该变量引用指向不可改，而非指向的对象不可改。
finally—在异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块。

final是全局变量声明的时候使用，意思是这个变量不可被修改，不可被override，一般用于声明常量，或者系统设置的值。
例子：public static final String a = "123"
意思是： 公共的（所有范围可见），静态的（系统中只存在一个），final的（不可被更改） 变量a，值是123
finally是在try-catch-finally块中配套使用，作用是，不管代码执行了try还是catch，最后一定会执行finally里面的代码

例子：
try{
这里写一些可能出现异常的代码
}catch(Exception e){
出现了异常就执行这里的代码。否则不执行
}finally{
无论有没有异常，都执行这里的代码
}

final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承；
finally是异常处理语句结构的一部分，表示总是执行 如：  try{ 发生异常的语句}catch（异常类  变量）{异常处理}finally{最终需要被执行的语句，不管是否发生异常都执行}
关于以上两个，上面的几楼说的比较详细了，再谈谈finalize,  finalize是Object类中的一个方法，在进行垃圾回收的时候会调用被回收对象的finalize方法，可以覆盖此方法提供垃圾收集时的其他资源的回收，代码如下：

1. class FinalizeDemo
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 Person p=new Person("张三",23);
   
6.                 p=null;
   
7.                 System.gc();//手动回收垃圾对象
   
8.                
   
9.         }
   
10. }
    
11. 
    
12. 
    
13. class Person
    
14. {
    
15.         String name;
    
16.         int age;
    
17.         Person(String name,int age)
    
18.         {
    
19.                 this.name=name;
    
20.                 this.age=age;
    
21.         }
    
22. 
    
23.         public void finalize() throws Throwable //对象被回收时候被调用
    
24.         {   
    
25.                 System.out.println(this.name+"\t"+this.age+" 对象被回收！");
    
26.         }
    
27. }

复制代码

finally一般在异常捕捉时使用，如IO操作时流对象的关闭，一般将要关闭的对象都放在finally代码块中。

final:修饰符（关键字）如果一个类被声明成final，意味它不能在派生出子类，不能作为父类被继承。因此一个类不能既被声明时final和ABSTRACT的。
将变量或方法声明是final，可以保证它们在使用中不被改变。被声明成final的变量必须在声明时给出其初始值，而在以后的引用中只能被读取，不能被改变。被声明final的方法也只能使用不能覆盖。

finally:在异常处理时提供finally块来执行任何清除操作。如果抛出一个异常，那么相匹配Catch子句就会执行，然后控制块会进入finally块。

final:修饰符（关键字）如果一个类被声明成final，意味它不能在派生出子类，不能作为父类被继承。因此一个类不能既被声明时final和ABSTRACT的。
将变量或方法声明是final，可以保证它们在使用中不被改变。被声明成final的变量必须在声明时给出其初始值，而在以后的引用中只能被读取，不能被改变。被声明final的方法也只能使用不能覆盖。

finally:在异常处理时提供finally块来执行任何清除操作。如果抛出一个异常，那么相匹配Catch子句就会执行，然后控制块会进入finally块。

final可以修饰三种情况 ： 数据、方法、类：
修饰数据 ： 我们需要一个永不改变的编译时常量，或者一个在运行时被初始化的值，而不希望它被改变时用到final。
修饰方法 ： 它可以锁定方法，以防止任何继承类修改，并且不会被覆盖。类中所以的private方法都隐式地指定为final。
修饰类 ： 当一个类用final修饰是，表示你不想它被其他的类继承，你对该类的设计不需要做任何的改动，或者处于安全考虑，你不希望它有子类。
finally ： 一般用于释放资源，因finally代码块中的内容为一定要执行的内容。

final说的比较详细了，我说说finally。
finally在异常处理时，用在无论try部分中是否抛出异常，都执行finally的代码，通常用于内存回收。
虽然java没有析构函数，但是java有垃圾回收机制，为什么还要执行finally呢？
主要一个原因就是把资源恢复或者关闭，或者存在无论是否异常，都一定要执行的代码。比如：
public class TestFinally{
         try {
              func.runNow();
         }
         catch(testException e) {
          //处理异常
          }
         finally {
              func.stopNow();
          }

}
无论func是否执行完毕，在外层函数结束时，func必须是停止状态。这个状态包括关闭输入输出流，保存文件，关闭网络连接，清除屏幕等操作。
还有一种情况是恢复数据，重置现在的数据，以便在下次执行时不出现异常，恢复到出现此异常之前的状态。比如static 定义的数据。

finally有时候会产生一种奇怪的现象，就是finally中如果产生异常，并且这个异常是处于另一个try-catch之内，那么finally产生的异常就会取代之前的异常，并被外围的异常处理接收到。
这样前一个异常就会丢失，给调试带来麻烦。
public class TestFinally{
       try{
          try {
              throw new testException(); //抛出异常。
         }
         catch(testException e) {
          //处理异常
          }
         finally {
              throw new testException();
          }
       }catch(Exception e) {
        //只能接收到finally中产生的异常。
       }

}

最后一条，不要在finally中使用return。同样会导致异常丢失。

final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
finally是异常处理语句结构的一部分，表示总是执行。
finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等

final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
finally是异常处理语句结构的一部分，表示总是执行。