Ⅰ java中final，finally和finalize的区别
1. final
在java中，final可以用来修饰类，方法和变量（成员变量或局部变量）。下面将对其详细介绍。
1.1 修饰类
当用final修饰类的时，表明该类不能被其他类所继承。当我们需要让一个类永远不被继承，此时就可以用final修饰，但要注意：
final类中所有的成员方法都会隐式的定义为final方法。
1.2 修饰方法
使用final方法的原因主要有两个：
(1) 把方法锁定，以防止继承类对其进行更改。
(2) 效率，在早期的java版本中，会将final方法转为内嵌调用。但若方法过于庞大，可能在性能上不会有多大提升。因此在最近版本中，不需要final方法进行这些优化了。
final方法意味着“最后的、最终的”含义，即此方法不能被重写。
注意：若父类中final方法的访问权限为private，将导致子类中不能直接继承该方法，因此，此时可以在子类中定义相同方法名的函数，此时不会与重写final的矛盾，而是在子类中重新地定义了新方法。
1.3 修饰变量
final成员变量表示常量，只能被赋值一次，赋值后其值不再改变。类似于C++中的const。
当final修饰一个基本数据类型时，表示该基本数据类型的值一旦在初始化后便不能发生变化；如果final修饰一个引用类型时，则在对其初始化之后便不能再让其指向其他对象了，但该引用所指向的对象的内容是可以发生变化的。本质上是一回事，因为引用的值是一个地址，final要求值，即地址的值不发生变化。
final修饰一个成员变量（属性），必须要显示初始化。这里有两种初始化方式，一种是在变量声明的时候初始化；第二种方法是在声明变量的时候不赋初值，但是要在这个变量所在的类的所有的构造函数中对这个变量赋初值。
当函数的参数类型声明为final时，说明该参数是只读型的。即你可以读取使用该参数，但是无法改变该参数的值。
2. finally
finally作为异常处理的一部分，它只能用在try/catch语句中，并且附带一个语句块，表示这段语句最终一定会被执行（不管有没有抛出异常），经常被用在需要释放资源的情况下。（×）（这句话其实存在一定的问题）
很多人都认为finally语句块一定会执行，但真的是这样么？答案是否定的，例如下面这个例子：
只有与finally对应的try语句块得到执行的情况下，finally语句块才会执行。以上两种情况在执行try语句块之前已经返回或抛出异常，所以try对应的finally语句并没有执行。
3. finalize
finalize()是在java.lang.Object里定义的，也就是说每一个对象都有这么个方法。这个方法在gc启动，该对象被回收的时候被调用。其实gc可以回收大部分的对象（凡是new出来的对象，gc都能搞定，一般情况下我们又不会用new以外的方式去创建对象），所以一般是不需要程序员去实现finalize的。
特殊情况下，需要程序员实现finalize，当对象被回收的时候释放一些资源，比如：一个socket链接，在对象初始化时创建，整个生命周期内有效，那么就需要实现finalize，关闭这个链接。
使用finalize还需要注意一个事，调用super.finalize();
一个对象的finalize()方法只会被调用一次，而且finalize()被调用不意味着gc会立即回收该对象，所以有可能调用finalize()后，该对象又不需要被回收了，然后到了真正要被回收的时候，因为前面调用过一次，所以不会调用finalize()，产生问题。 所以，推荐不要使用finalize()方法，它跟析构函数不一样。
Ⅱ java中final和finally的区别
final—修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为内父类被继承。因容此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载。
finally—在异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）
Ⅲ JAVA语言如何进行异常处理，关键字：throws,throw,try,catch,finally分别代表什么意义
package com.fml.resource;
import javax.swing.Icon;
import javax.swing.JOptionPane;
public class CaiShuZi4JOptionPane {
/**
* @param args
*/
public static void main(String[] args) {
Icon icon = null;
boolean bl = false;
int put = 0;
int c = (int) (((Math.random())*100)+1); //获取一个1-100的随机数
System.out.println("你获取的随机数是："+c); //打印你的随机数字
String str1 = (String) JOptionPane.showInputDialog(null,"请输入你的猜测数字(1-100)： ","猜数字游戏",JOptionPane.PLAIN_MESSAGE,icon,null,"在这输入"); //第一次输入你的猜测数字
if(str1==null){
JOptionPane.showMessageDialog(null, "你已经取消了本次游戏"); //如果你点取消那么本次游戏结束
}else{
bl = num(str1); //判断是输入的是不是数字或者是整数
if(true==bl){ //如果是数字的话进入与随机数比较的程序
System.out.println("你输入的数字是："+str1); //打印你输入的数字
put = Integer.valueOf(str1);
for(int i = 4;i > 0;i--){ //i是你可以猜测的次数
if(put==c){
JOptionPane.showMessageDialog(null, "恭喜你猜对了，正确答案是:"+c+"。"); //如果你猜对了就直接结束循环
break;
}else if(put>c){ //如果输大了就让你再次从新输入
str1 = (String) JOptionPane.showInputDialog(null,"你的输入过大。你还有"+i+"次机会，请重新输入： ","猜数字游戏",JOptionPane.PLAIN_MESSAGE,icon,null,"在这输入");
if(str1==null){
JOptionPane.showMessageDialog(null, "你已经取消了本次输入");
break;
}else{
bl =num(str1);
if(true==bl){
put = Integer.valueOf(str1);
}else{
JOptionPane.showMessageDialog(null, "你的输入不正确，请重新输入");
}
}
}else if(put<c){ //如果你输小了也让你从新输入
str1 = (String) JOptionPane.showInputDialog(null,"你的输入过小。你还有"+i+"次机会，请重新输入： ","猜数字游戏",JOptionPane.PLAIN_MESSAGE,icon,null,"在这输入");
if(str1==null){
JOptionPane.showMessageDialog(null, "你已经取消了本次输入");
break;
}else{
bl =num(str1);
if(true==bl){
put = Integer.valueOf(str1);
}else{
JOptionPane.showMessageDialog(null, "你的输入不正确，请重新输入");
}
}
}
}
}else if(bl==false){ //这个 是你第一次如果填写的不是数字的话也会结束本次游戏
JOptionPane.showMessageDialog(null, "请您下次按要求填写。本次游戏结束");
}
if(true==bl && c!=put){ //如果你i次都没猜对，那么就直接告诉你这个数十什么
JOptionPane.showMessageDialog(null, "很遗憾你没能猜对，这个数字是："+c+".");
}
}
}
public static boolean num(String value){ //一个静态方法，判断你输入的是不是数字
try {
Integer.parseInt(value);
return true;
} catch (Exception e) {
return false;
}
}
}
你先看看我的实例，最下面的一个就是捕获异常和进行处理的方法
在整个JAVA的异常处理中，实际上也是按照面向对象的方式进行处理，处理的步骤如下：
1、一旦产生异常，将会产生一个异常类的实例化对象。
2、在try语句中对这个异常对象进行捕获。
3、产生的异常对象与catch语句中的各个异常类型进行匹配，如果匹配成功，则执行catch语句中的代码。
Try{
}catch(…){
} finally{
……
}
这个finally如果没有中途退出最后是一定会执行到的。
throws是用在主类前面的，是让他的父类来处理这个异常。不在此类中处理
Ⅳ 关于JAVA中finally的问题....
首先finally 结构使代码总会执行，而不管有无异常发生
其次try, catch, finally中fianlly的throw/return的级别最高，
举例来说
public class Finally{
public static void main(String[] args)
{
Finally e=new Finally();
System.out.println(e.tryThis());
}
public void thooo() throws Exception {
throw new Exception();
}
public int tryThis()
{
try{
System.out.println("1");
thooo();
return 1;
}catch(Exception ex){
System.out.println("2");
return 2;
}finally{
System.out.println("4");
return 3;
}
}
}
上面这个程序输出的结果是
1
2
4
3
看到么？try和catch的return根本没有作用，因为finally的代码优先级最高！
不过像以上你的应用是不合理的，通常在finally语句中是进行资源的清除工作。如关闭打开的文件和通讯句柄，或者数据库链接等。
如果finally里面没有return或者exception，那么你的catch语句的exception 或者 return 语句将被如期执行了。
哎~~~10分好累
Ⅳ java中的finally怎么使用
try {
语句块：可能抛出异常的语句
} catch (Exception e) {
捕获异常
}
finally{
无论是抛出了异常还是没有抛出异内常都要执行容的语句块
}
Ⅵ 试解释Java与Finally的意义及用法
一、 finally：java的一种异常处理机制。
finally是对Java 异常处理模型的最佳补充。finally 结构使代码总会执行，而不管有无异常发生。使用 finally 可以维护对象的内部状态，并可以清理非内存资源。特别是在关闭数据库连接这方面，如果程序员把数据库连接的close()方法放到finally中，就会大大降低程序出错的几率。
二、在java中的finally关键一般与try一起使用，在程序进入try块之后，无论程序是因为异常而中止或其它方式返回终止的，finally块的内容一定会被执行
写个例子来说明下：
[java] view plainprint?
<pre class="java" name="code">package com.teedry.base;
public class TryAndFinallyTest {
public static void main(String[] args) throws Exception{
try{
int a = testFinally(2);
System.out.println("异常返回的结果a:"+a);
}catch(Exception e){
int b = testFinally(1);
System.out.println("正常返回的结果b:"+b);
}
int b = testFinally(3);
System.out.println("break返回的结果:"+b);
b = testFinally(4);
System.out.println("return返回的结果:"+b);
}
static int testFinally(int i) throws Exception{
int flag = i;
try{//一旦进去try范围无论程序是抛出异常或其它中断情况，finally的内容都会被执行
switch(i){
case 1:++i;break;//程序 正常结束
case 2:throw new Exception("测试下异常情况");
case 3:break;
default :return -1;
}
}finally{
System.out.println("finally coming when i="+flag);
}
return i;
}
}
</pre><br>
<pre></pre>
<p>执行结果如下：</p>
<p>finally coming when i=2<br>
finally coming when i=1<br>
正常返回的结果b:2<br>
finally coming when i=3<br>
break返回的结果:3<br>
finally coming when i=4<br>
return返回的结果:-1</p>
<p> </p>
<p>结果说明无论上述什么情况，finally块总会被执行。 </p>
二 try的范围内存在exception的话，就会在exception的位置跳到exception哪里，然后执行完exception之后就马上进入finally。
假如exception范围内存在return这些的也会执行finally
假如try范围内不存在exception的话，就执行完try范围内代码之后进入finally执行，finally代码
其实，一般finally写的代码就是流的关闭语句，
假如还是不明白，试一下运行我下面写的几个代码就知道的了。假如try不存在exception的话：
try{
System.out.println("try");
}catch(Exception e)
{
System.out.println("Exception");
}
finally{
System.out.println("Finally");
}
假如try中存在exception的：
try{
String demo = null;
demo.split(";");
System.out.println("try");
}catch(Exception e)
{
System.out.println("Exception");
}
finally{
System.out.println("Finally");
}
假如try中存在exception，然后exception中存在跳出语句的：
try{
String demo = null;
demo.split(";");
System.out.println("try");
}catch(Exception e)
{
System.out.println("Exception");
return；
}
finally{
System.out.println("Finally");
}
假如try中不存在exception，但是try中存在跳出语句的：
try{
System.out.println("try");
return;
}catch(Exception e)
{
System.out.println("Exception");
}
finally{
System.out.println("Finally");
}
Ⅶ java为什么需要finally
无论是否出现异常不也要执行吗？这句话是有问题的，有些异常如果不处理，也就不会继续下去了。即程序从catch里改变控制流，不会执行后面的语句。加了finally，可以保证即使因为异常，后面的代码不会被执行，但是finally里面的语句还是会执行，这样可以释放一些申请的资源～或者做一些其他工具，比如作profiling统计等。
你可以在catch里面加个return来模拟类似情况，看看后面的语句会不会执行？
看看finally子例程里面的语句会不会执行，以及他们的执行顺序...
Ⅷ java中的“try - catch -finally”结构中的“finally”有哪些用途
可以这么理解来
try块中的内容是在无自异常发生时执行到结束
catch块中的内容，是在try块中内容发生catch所声明的异常时，跳转到catch块执行
finally块则是无论是否发生异常，都会执行finally块的内容
所以，代码逻辑中有需要无论发生什么都必须执行的代码，则可以放在finally块中
例如:最常见的就是把关闭connection、释放资源等的代码放在finally块中