文档章节

JAVA final finally finalize区别

qq22734179
 qq22734179
发布于 2014/03/21 13:15
字数 3426
阅读 61
收藏 3

简单区别: 

   

 

中等区别:

 

   虽然这三个单词在Java中都存在,但是并没有太多关联

 

 

       finaljava中的关键字,修饰符。

 

           1.如果一个类被声明为final,就意味着它不能再派生出新的子类,不能作为父类被继承。因此,一个类不能同时被声明为absrtact抽象类的和final的类。

           2.如果将变量或者方法声明为final,可以保证它们在使用中不被改变.

                 2.1 被声明为final变量必须在声明时给定初值,而在以后的引用中只能读取,不可修改 

                 2.2被声明final方法只能使用不能重载

 

 

       finallyjava的一种异常处理机制。

             

              finally是对Java 异常处理模型的最佳补充。finally 结构使代码总会执行,而不管有无异常发生。使用 finally 可以维护对象的内部状态,并可以清理非内存资源。特别是在关闭数据库连接这方面,如果程序员把数据库连接的close()方法放到finally中,就会大大降低程序出错的几率。

 

       finalizeJava中的一个方法名。

     

               Java技术使用finalize()方法在垃圾收集器将对象从内存中清除出去前,做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是Object类中定义的,因此所有的类都继承了它。子类覆盖finalize()方法以整理系统资源或者执行其他清理工作。finalize()方法是在垃圾收集器删除对象之前对这个对象调用的。

 

 

详细区别:

     这是一道再经典不过的面试题了,我们在各个公司的面试题中几乎都能看到它的身影。finalfinallyfinalize虽然长得像孪生三兄弟一样,但是它们的含义和用法却是大相径庭。这一次我们就一起来回顾一下这方面的知识。

 

1.final关键字
我们首先来说说final。它可以用于以下四个地方:
     1. 定义变量,包括静态的和非静态的。
     2. 定义方法的参数。
     3. 定义方法。
     4. 定义类。
我们依次来回顾一下每种情况下final的作用。

 

1.1 定义变量,包括静态的和非静态的。定义方法的参数

第一种情况:

          如果final修饰的是一个基本类型,就表示这个变量被赋予的值不可变的,即它是个常量;

          如果final修饰的是一个对象,就表示这个变量被赋予的引用不可变

这里需要提醒大家注意的是,不可改变的只是这个变量所保存的引用,并不是这个引用所指向的对象。

 

第二种情况:

           final的含义与第一种情况相同。

 

实际上对于前两种情况,有一种更贴切的表述final的含义的描述,那就是,如果一个变量或方法参数被final修饰,就表示它只能被赋值一次,但是JAVA虚拟机为变量设定的默认值不记作一次赋值


final修饰的变量必须被初始化。初始化的方式有以下几种:
     1. 在定义的时候初始化。
     2. final变量可以在初始化块中初始化,不可以在静态初始化块中初始化。
     3. 静态final变量可以在静态初始化块中初始化,不可以在初始化块中初始化。
     4. final变量还可以在类的构造器中初始化,但是静态final变量不可以。


通过下面的代码可以验证以上的观点:

Java代码
public class FinalTest {
     // 在定义时初始化
     public final int A = 10;

 

    // 在初始化块中初始化

     public final int B;
     {
          B = 20;
     }


     // 非静态final变量不能在静态初始化块中初始化
     // public final int C;
     // static {
          // C = 30;
     // }


     // 静态常量,在定义时初始化
     public static final int STATIC_D = 40;

 

   // 静态常量,在静态初始化块中初始化

     public static final int STATIC_E;
     static {
          STATIC_E = 50;
     }


     // 静态变量不能在初始化块中初始化
     // public static final int STATIC_F;
     // {
          // STATIC_F = 60;
     // }


       public final int G;


     // 静态final变量不可以在构造器中初始化
     // public static final int STATIC_H;
     // 在构造器中初始化
          public FinalTest() {
               G = 70;

// 静态final变量不可以在构造器中初始化

// STATIC_H = 80;

 

// 给final的变量第二次赋值时,编译会报错

// A = 99;

// STATIC_D = 99;

          }

// final变量未被初始化,编译时就会报错

// public final int I;

// 静态final变量未被初始化,编译时就会报错

// public static final int STATIC_J;

}

 

我们运行上面的代码之后出了可以发现final变量(常量)和静态final变量(静态常量)未
被初始化时,编译会报错。


final修饰的变量(常量)比非final的变量(普通变量)拥有更高的效率,因此我们在实
际编程中应该尽可能多的用常量来代替普通变量,这也是一个很好的编程习惯。

 

1.2 定义方法
final用来定义一个方法时,会有什么效果呢?正如大家所知,它表示这个方法不可以被
子类重写,但是它这不影响它被子类继承。我们写段代码来验证一下:

 

Java代码
public class ParentClass {
     public final void TestFinal() {
          System.out.println("父类--这是一个final方法");
     }
}
public class SubClass extends ParentClass {
     /**
     * 子类无法重写(override)父类的final方法,否则编译时会报错
     */
     // public void TestFinal() {
     // System.out.println("子类--重写final方法");
     // }
     public static void main(String[] args) {
          SubClass sc = new SubClass();
          sc.TestFinal();
     }
}

这里需要特殊说明的是,具有private访问权限的方法也可以增加final修饰,但是由于子类
无法继承private方法,因此也无法重写它。编译器处理private方法时,是按照final方法
来对待的,这样可以提高该方法被调用时的效率。不过子类仍然可以定义同父类中的
private方法具有同样结构的方法,但是这并不会产生重写的效果,而且它们之间也不存在必
然联系。

 

 

1.3 定义类

最后我们再来回顾一下final用于类的情况。这个大家应该也很熟悉了,因为我们最常用的String类就是final。由于final类不允许被继承,编译器在处理时把它的所有方法都当作final,因此final类比普通类拥有更高的效率。而由关键字abstract定义的抽象类含有必须由继承自它的子类重载实现的抽象方法,因此无法同时用finalabstract来修饰同一个类。同样的道理,final也不能用来修饰接口。 final的类的所有方法都不能被重写,但这并不表示final的类的属性(变量)值也是不可改变的,要想做到final类的属性值不可改变必须给它增加final修饰,请看下面的例子:

 

Java代码
public final class FinalTest {

int i = 10;

 final int j = 50;

public static void main(String[] args) {

     FinalTest ft = new FinalTest();

     ft.i = 99;          // final类FinalTest的属性值 i是可以改变的,因为属性值i前面没有final修//

// ft.j = 49;         // 报错....因为 j 属性是final 的不可以改变。

     System.out.println(ft.i);

}

}

运行上面的代码试试看,结果是99,而不是初始化时的10。


2.finally语句


接下来我们一起回顾一下finally的用法。这个就比较简单了,它只能用在try/catch语句中,
并且附带着一个语句块,表示这段语句最终总是被执行。请看下面的代码:

Java代码
public final class FinallyTest {

public static void main(String[] args) {

try {

     throw new NullPointerException();

} catch (NullPointerException e) {

     System.out.println("程序抛出了异常");

} finally {

 //这里总会被执行,不受break,return影响另如数据库连接的close()一般写在这里,可以降低程序的出错几率

     System.out.println("执行了finally语句块");                      

}

}

}


 

运行结果说明了finally的作用:
1. 程序抛出了异常
2. 执行了finally语句块
请大家注意,捕获程序抛出的异常之后,既不加处理,也不继续向上抛出异常,并不是良好
的编程习惯,它掩盖了程序执行中发生的错误,这里只是方便演示,请不要学习。
那么,有没有一种情况使finally语句块得不到执行呢?大家可能想到了
returncontinuebreak这三个可以打乱代码顺序执行语句的规律。那我们就来试试看,这
三个语句是否能影响finally语句块的执行:

Java代码
public final class FinallyTest {


          // 测试return语句

            结果显示:编译器在编译return new ReturnClass();时,将它分成了两个步骤,new ReturnClass()return,前一个创建对象的语句是在finally语句块之前被执行的,而后一个return语句是在finally语句块之后执行的,也就是说finally语句块是在程序退出方法之前被执行的

public ReturnClass testReturn() {

try {

     return new ReturnClass();

} catch (Exception e) {

     e.printStackTrace();

} finally {

     System.out.println("执行了finally语句");

}

return null;

}

 

// 测试continue语句

public void testContinue() {

for (int i = 0; i < 3; i++) {

try {

System.out.println(i);

if (i == 1) {

continue;

}

} catch (Exception e) {

     e.printStackTrace();

} finally {

     System.out.println("执行了finally语句");

}

}

}

 

// 测试break语句

public void testBreak() {

for (int i = 0; i < 3; i++) {

try {

     System.out.println(i);

     if (i == 1) {

          break;

     }

} catch (Exception e) {

     e.printStackTrace();

} finally {

     System.out.println("执行了finally语句");

}

}

}

 

public static void main(String[] args) {

 

FinallyTest ft = new FinallyTest();

 

// 测试return语句

ft.testReturn();

System.out.println();

 

// 测试continue语句

ft.testContinue();

System.out.println();

 

// 测试break语句

ft.testBreak();

}

}
class ReturnClass {
     public ReturnClass() {
          System.out.println("执行了return语句");
     }
}

上面这段代码的运行结果如下:
1. 执行了return语句
2. 执行了finally语句
3.
4. 0
5. 执行了finally语句
6. 1
7. 执行了finally语句
8. 2
9. 执行了finally语句
10.
11. 0
12. 执行了finally语句
13. 1
14. 执行了finally语句

 

 

很明显,returncontinuebreak没能阻止finally语句块的执行。从输出的结果来看,

return语句似乎在 finally语句块之前执行了,事实真的如此吗?我们来想想看,return语句
的作用是什么呢?是退出当前的方法,并将值或对象返回。如果 finally语句块是在return
句之后执行的,那么return语句被执行后就已经退出当前方法了,finally语句块又如何能被
执行呢?因此,正确的执行顺序应该是这样的:编译器在编译return new ReturnClass();时,
将它分成了两个步骤,new ReturnClass()return,前一个创建对象的语句是在finally语句块
之前被执行的,而后一个return语句是在finally语句块之后执行的,也就是说finally语句块
是在程序退出方法之前被执行的。同样,finally语句块是在循环被跳过(continue)和中断
break)之前被执行的。

//finally能保证在何种情况下,文件流的句柄都得以被正确关闭

// 该方法主要用于清理非内存性质的资源(垃圾回收机制无法

// 处理的资源,如数据库连接、 Socket 关闭、文件关闭等等


3.finalize方法
最后,我们再来看看finalize,它是一个方法,属于java.lang.Object类,它的定义如下:
Java代码
protected void finalize() throws Throwable { }
众所周知,finalize()方法是GCgarbage collector)运行机制的一部分
在此我们只说说finalize()方法的作用是什么呢?
finalize()方法是在GC清理它所从属的对象时被调用的,如果执行它的过程中抛出了无法捕
获的异常(uncaught exception),GC将终止对改对象的清理,并且该异常会被忽略;直到
下一次GC开始清理这个对象时,它的finalize()会被再次调用。
请看下面的示例:

Java代码
public final class FinallyTest {

// 重写finalize()方法

protected void finalize() throws Throwable {

     System.out.println("执行了finalize()方法");

}

public static void main(String[] args) {

     FinallyTest ft = new FinallyTest();

     ft = null;

     System.gc();   

}

}

运行结果如下:
• 执行了finalize()方法

 

程序调用了java.lang.System类的gc()方法,引起GC的执行,GC在清理ft对象时调用了它
finalize()方法,因此才有了上面的输出结果。调用System.gc()等同于调用下面这行代码:
Java代码
Runtime.getRuntime().gc();
调用它们的作用只是建议垃圾收集器(GC)启动,清理无用的对象释放内存空间,但是GC
的启动并不是一定的,这由JAVA虚拟机来决定。直到 JAVA虚拟机停止运行,有些对象的
finalize()可能都没有被运行过,那么怎样保证所有对象的这个方法在JAVA虚拟机停止运行
之前一定被调用呢?答案是我们可以调用System类的另一个方法:
Java代码
public static void runFinalizersOnExit(boolean value) {
//other code
}
给这个方法传入true就可以保证对象的finalize()方法在JAVA虚拟机停止运行前一定被运行
了,不过遗憾的是这个方法是不安全的,它会导致有用的对象finalize()被误调用,因此已经
不被赞成使用了。
由于finalize()属于Object类,因此所有类都有这个方法,Object的任意子类都可以重写
override)该方法,在其中释放系统资源或者做其它的清理工作,如关闭输入输出流。
通过以上知识的回顾,我想大家对于finalfinallyfinalize的用法区别已经很清楚了。

 


本文转载自:http://wenku.baidu.com/link?url=8Ofh60Gj6aIO1YzhXKzI5qeN6vNBPu9RY6MjCxvqJNvyPhMTM0q_JHIqOvOf0K0aS...

qq22734179
粉丝 2
博文 6
码字总数 349
作品 0
威海
程序员
私信 提问
03《Java核心技术》之谈谈final、finally、 finalize有什么不同?

一、提出问题 Java 语言有很多看起来很相似,但是用途却完全不同的语言要素,这些内容往往容易成为面试官考察你知识掌握程度的切入点。 今天,我要问你的是一个经典的 Java 基础题目,谈谈 ...

飞鱼说编程
2018/09/14
78
0
异常处理——finally的特点、作用及面试题

finally的特点: (1) 是异常处理的一部分,用于释放资源; (2) 一般来说,被finally控制的代码一定会执行; (3) 特殊情况:如果在执行到finally之前jvm退出了(比如:System.exit(0),但是,...

G_66_hero
2018/09/12
0
0
java程序员基础进阶篇,万丈高楼平地起

一.final,finally,finalize 三者区别 Final是一个修饰符: 当final修饰一个变量的时候,变量变成一个常量,它不能被二次赋值 当final修饰的变量为静态变量(即由static修饰)时,必须在声明这...

启示录是真的
2018/05/26
0
0
Java深究之final、finally、finalize三者的区别

在java中final、finally、finalize三者在写法上很相近,但是实际含义和作用却是相差甚远。本文主要是来深层的研究下这三者的用法以及之间的区别 1.final 属性:java中的关键字,修饰符 作用:...

MaxBill
2018/06/29
40
0
Java finalize方法

《JAVA编程思想》: java提供finalize()方法,垃圾回收器准备释放内存的时候,会先调用finalize()。 (1).对象不一定会被回收。 (2).垃圾回收不是析构函数。 (3).垃圾回收只与内存有关。 (4)....

清风伴月
2017/10/22
46
0

没有更多内容

加载失败,请刷新页面

加载更多

【2019年8月版本】OCP 071认证考试最新版本的考试原题-第5题

choose the best answer The CUSTOMERS table has a CUST_LAST_NAME column of data type VARCHAR2. The table has two rows whose COST_LAST_MANE values are Anderson and Ausson. Which q......

oschina_5359
34分钟前
3
0
电脑怎样制作流程图?分享绘制流程图方法

流程图的绘制可以用很多方法来实现,小编经常使用电脑对流程图进行绘制,即简单又便利,相信很多朋友都因为不知道怎样绘制流程图而选择了放弃,今天这篇文章希望可以让大家重拾绘制流程图的信...

干货趣分享
36分钟前
3
0
Elasticsearch 7.x 之文档、索引和 REST API 【基础入门篇】

前几天写过一篇《Elasticsearch 7.x 最详细安装及配置》,今天继续最新版基础入门内容。这一篇简单总结了 Elasticsearch 7.x 之文档、索引和 REST API。 什么是文档 文档Unique ID 文档元数据...

泥瓦匠BYSocket
39分钟前
4
0
TL665x-EasyEVM开发板处理器、flash、RAM

TL665x-EasyEVM是广州创龙基于SOM-TL665x核心板研发的一款TI C66x多核定点/浮点高性能DSP开发板,采用核心板+底板方式,底板尺寸为200mm*106.65mm,采用4*50pin和1*80pin B2B工业级连接器,稳...

Tronlong创龙
44分钟前
3
0
DevExpress Report-XRTable绑定数据

将从跳转前的页面(A)中获取传入的数据(dtOrd、BatchID、ModelID),绑定到Report报表对应的控件 ,代码如下: this.xrtBatchID.Text = sBatchID; this.xrtModel.Text ...

_Somuns
45分钟前
3
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部