Java编程中。常常会使用到异常处理，而finally看似的是try/catch后对逻辑处理的完好，事实上里面却存在非常多隐晦的陷阱。final常见于变量修饰，那么你在内部类中也见过吧。finalize作为GC回收对象前的一道门，什么时候运行。运行效果又是如何。有时看看又忘了。以下是我总结网上朋友的一些博文及其帖子对三者进行总结。（重点讲下finally）
先看final
- Final修饰变量不能被又一次赋值，其修饰实例变量时，定义时指定值则可视为“宏变量”。在非静态代码块和构造器中初始化值则不是。其修饰类变量时。仅仅有在定义时指定值才视为“宏变量”，在静态代码块中初始化则不是。
- Final修饰的方法不能被重写
- Final修饰的类不能被继承
- 内部类一般使用final修饰的局部变量。
在看finalize
- 系统调用finalize方法具有不确定性
- finalize方法是protected方法。子类能够覆盖该方法以实现资源清理工作，GC在回收对象之前调用该方法。一般当对象在变成不可到达的时候，GC会推断是否覆盖该方法，假设没有覆盖就直接回收。假设覆盖就把该对象放进F-Queue队列并由一低优先级线程运行该对象的finalize方法，然后再次推断是否可达。
- 尽量不要去调用finalize，假设调用。则避免对象再生，多用于关闭流。
最后细斟finally
- Finall语句在return语句运行之后，return返回之前运行；
- Finally块中的return语句运行结果覆盖try和catch中运行的return语句运行结果
- Finally块中操作try/catch返回基本变量时。结果不受finally操作影响
- Finally块中操作try/catch返回引用对象时。
结果受finally操作影响
以下给出几个样例验证finally的4个重要观点
样例1代码例如以下：
package java_zhaohuaxishi;
public class Example1 {
public int test(){
int i = 0;
try{
i = 10;
System.out.println("try");
return i+=10;
}catch(Exception e){
i = 20;
return 200;
}finally{
System.out.println("finally");
System.out.println(i);
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(new Example1().test());
}
}
执行结果：
try finally 20 20
这也意味着finally打印出来的是try中return已经计算了的，验证观点一。
样例2代码例如以下：
package java_zhaohuaxishi;
public class Example1 {
public int test(){
int i = 0;
try{
i = 10;
return 100;
}catch(Exception e){
i = 20;
return 200;
}finally{
return i;
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(new Example1().test());
}
}
上述时没有出现异常情况，打印例如以下：
10
再给出出现异常情况，代码例如以下：
package java_zhaohuaxishi;
public class Example2 {
public int test(){
int i = 0;
try{
i = 10/0;
return 100;
}catch(Exception e){
i = 20;
return 200;
}finally{
return i;
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(new Example2().test());
}
}
打印结果例如以下：
20
结果是：不管出现异常与否，finally的return总会覆盖try/catch中return的结果。验证观点二。
样例3代码例如以下：
package java_zhaohuaxishi;
public class Example5 {
public int test(){
int i = 0;
try{
i = 10;
return i;
}catch(Exception e){
i = 20;
return i;
}finally{
i=30;
//return i;
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(new Example5().test());
}
}
打印结果例如以下：
10
能够看到。实际上finally改动i变量是不起作用的。验证观点三。
样例4代码例如以下：
package java_zhaohuaxishi;
class Test{
int num;
public Test(int num){
this.num = num;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
}
public class Example3 {
public Test test(){
Test t = new Test(0);
try{
t.setNum(10);
return t;
}catch(Exception e){
t.setNum(20);
return t;
}finally{
t.setNum(30);
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(new Example3().test().getNum());
}
}
打印结果例如以下：
30
从上述结果来看，finally操作的对象确实是与try上的同一个对象。那么我们比較上面观点三，操作变量的时候是不能更改的，想想有点诡异。我们看以下代码：
package java_zhaohuaxishi;
class Test{
int num;
public Test(int num){
this.num = num;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
}
public class Example3 {
public int test(){
Test t = new Test(0);
try{
t.setNum(10);
System.out.println(t.getNum());
return t.getNum();
}catch(Exception e){
t.setNum(20);
return t.getNum();
}finally{
System.out.println(t.getNum());
t.setNum(30);
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(new Example3().test());
}
}
这次我们不在返回对象。而是返回一个int变量。从观点一我们能够知道，返回的t.getNum（）实际上是会先计算再保存起来。那么假设我们在finally中在去改变t的num，实际上t的num会被改变，然而返回的应该还是10。
打印结果例如以下：
10 30 10
果然！这与我们预先的是一模一样。假设有人认为finally中t对象可能与try中不一致。以下样例将会让你认为非常奇妙：
package java_zhaohuaxishi;
class Test4{
int num;
public Test4(int num){
this.num = num;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
}
public class Example4 {
public Test4 test(Test4 t){
System.out.println("传进去的t："+t.hashCode());
try{
t.setNum(10);
return t;
}catch(Exception e){
t.setNum(20);
return t;
}finally{
//t.setNum(30);
System.out.println("finally改动前："+t.hashCode());
t = new Test4(0);
System.out.println("finally改动后："+t.hashCode());
//return t;
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Test4 t = new Test4(0);
System.out.println("return返回对象"+new Example4().test(t).hashCode());
System.out.println("最后的t："+t.hashCode());
}
}
我们来看看打印结果：
传进去的t：2004703190 finally改动前：2004703190 finally改动后：1175576547 return返回对象2004703190 最后的t：2004703190
这结果看起来非常奇妙。我们验证观点四的时候操作对象是起作用的！然而当我们试图去改动t引用让他指向其它对象的时候居然无效......
如有很多其它兴趣深入了解。可进一步认识JVM工作机制！
时间： 2024-11-06 15:20:07