final finally finalize

final

 //如果不是final 的话，我可以在checkInt方法内部把i的值改变（有意或无意的，

      //虽然不会改变实际调用处的值），特别是无意的，可能会引用一些难以发现的BUG

      publicstaticvoid checkInt(int i)

      {

            i = 200;//这样是可以的，不会编译出错的

            //do something

      }

 

      //如果是final 的话，我可以在checkInt方法内部就没办法把i的值改变

      //可以完全避免上面的问题

      publicstaticvoid checkInt(finalint i)

      {

            i = 200;//这样是不可以的，会编译出错的

            //do something

      }

 

      //final 的引用类型方法参数

      publicstaticvoid checkLoginInfo(final LoginInfo login)

      {

            login = new LoginInfo();//error,编译不过去

            //do something

      }

      //非final的引用类型方法参数

      publicstaticvoid checkLoginInfo(LoginInfo login)

      {

            //没有任何问题，但是肯定不符合此参数存在的初衷

            login = new LoginInfo();

            //do something

      }

 

---

在方法参数前面加final关键字就是为了防止数据在方法体中被修改。

主要分两种情况：第一，用final修饰基本数据类型；第二，用final修饰引用类型。

第一种情况，修饰基本类型（非引用类型）。这时参数的值在方法体内是不能被修改的，即不能被重新赋值。否则编译就通不过。例如：

1 public static void valid(final int ag){
2         ag=9;
3         ag=10;
4 }

错误提示：

第二种情况，修饰引用类型。这时参数变量所引用的对象是不能被改变的。作为引用的拷贝，参数在方法体里面不能再引用新的对象。否则编译通不过。例如：

1 public static void valid(final String[] ag){
2         ag=new String[9];
3 }

这个的提示和上面是一样的。：“ The final local variable param2 cannot be assigned. It must be blank and not using a compound assignment.“

但是对于引用，如果我是这样，则不会报任何错，完全能编译通过。但是运行会报错

1 public static void valid(final String[] ag){
2         ag[0]="5";
3         System.out.println(ag);
4 }

所以，final这个关键字，想用的话就用基本类型，还是很有作用的。

finally

与其他语言的模型相比，finally 关键字是对 Java 异常处理模型的最佳补充。finally 结构使代码总会执行，而不管有无异常发生。使用 finally 可以维护对象的内部状态，并可以清理非内存资源。 如果没有 finally，您的代码就会很费解。例如，下面的代码说明，在不使用 finally 的情况下您必须如何编写代码来释放非内存资源：

import java.net.*; 
import java.io.*;

class WithoutFinally 
{ 
      public void foo() throws IOException 
{ 
//在任一个空闲的端口上创建一个套接字 
ServerSocket ss = new ServerSocket(0); 
try 
        { 
       Socket socket = ss.accept(); 
       //此处的其他代码... 
} 
catch (IOException e) 
       { 
       ss.close();                                              //1 
       throw e; 
} 
//... 
ss.close();                                                //2 
} 
}

这段代码创建了一个套接字，并调用 accept 方法。在退出该方法之前，您必须关闭此套接字，以避免资源漏洞。为了完成这一任务，我们在 //2 处调用 close，它是该方法的最后一条语句。但是，如果 try 块中发生一个异常会怎么样呢？在这种情况下，//2 处的 close 调用永远不会发生。因此，您必须捕获这个异常，并在重新发出这个异常之前在 //1 处插入对 close 的另一个调用。这样就可以确保在退出该方法之前关闭套接字。

这样编写代码既麻烦又易于出错，但在没有 finally 的情况下这是必不可少的。不幸的是，在没有 finally 机制的语言中，程序员就可能忘记以这种方式组织他们的代码，从而导致资源漏洞。Java 中的 finally 子句解决了这个问题。有了 finally，前面的代码就可以重写为以下的形式：

import java.net.*; 
import java.io.*;

class WithFinally 
{ 
public void foo2() throws IOException 
{ 
//在任一个空闲的端口上创建一个套接字 
ServerSocket ss = new ServerSocket(0); 
try 
        { 
      Socket socket = ss.accept(); 
      //此处的其他代码... 
} 
finally 
        { 
       ss.close(); 
} 
} 
}

finally 块确保 close 方法总被执行，而不管 try 块内是否发出异常。因此，可以确保在退出该方法之前总会调用 close 方法。这样您就可以确信套接字被关闭并且您没有泄漏资源。在此方法中不需要再有一个 catch 块。在第一个示例中提供 catch 块只是为了关闭套接字，现在这是通过 finally 关闭的。如果您确实提供了一个 catch 块，则 finally 块中的代码在 catch 块完成以后执行。

finally 块必须与 try 或 try/catch 块配合使用。此外，不可能退出 try 块而不执行其 finally 块。如果 finally 块存在，则它总会执行。（无论从那点看，这个陈述都是正确的。有一种方法可以退出 try 块而不执行 finally 块。如果代码在 try 内部执行一条 System.exit(0); 语句，则应用程序终止而不会执行 finally 执行。另一方面，如果您在 try 块执行期间拨掉电源，finally 也不会执行。）

 

 

 

finalize 

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

Java语言规范，不仅不保证终结方法会被及时的执行，而且根本不保证他们会被执行。不应该依赖终结方法来更新重要的状态。