谈谈java中的final关键字

    在java的学习工作中，我们修饰变量、方法亦或是类，永远离不开关键字。比如static、synchronized、transient、final、native等等，真的要用好java，基本功肯定很重要，而掌握这些关键字的运用场景、产生效果就很有必要。今天自己想总结一下用到的一个关键字final。

   普适的认为：final关键字可以修饰变量、方法以及类。一个final变量的值不能改变，一个final方法不能被子类覆盖，而一个final类不能被继承。

    final变量：

                     1. 对于基本数据类型而言，说明变量值不能改变。而对于对象引用类型而言，则说明变量不能被重新赋值，指向新的对象。但是变量所引用的对象却可以被修改。

                     2. 变量的值可以在编译时确定，也可以是运行时随机生成的值来初始化。

                     3. 一个既是static又是final的变量只占据一段不能改变的内存空间。

                     4. 方法的参数列表中的参数可以是final类型，但是方法体内却无法修改参数。

                     5. 可以将某一个变量声明成final，却不给取赋值，而这个便是'空白final‘。但是，编译器都会确保空白final在使用前必须初始化。所以既然没在定义处初始化变量，那只能在构造函数里面进行处理了。

     下面展示一个例子，说明上面说到的几点知识：  

package com.ebay;

import java.util.Random;

class Gizmo{
	public void spin(){}
}

class Value{
    int i ;
    public Value(int i){
    	this.i = i ;
    }
    
    void containFinalParams(final Gizmo g){
    	//g = new Gizmo() ;   //方法的参数列表中的参数可以是final类型，但是方法体内却无法修改参数。
    }
}

public class FinalData {
	private String id ;
	public FinalData(String id){
		valueFour = 11 ; //可以将某一个变量声明成final，却不给取赋值，而这个便是'空白final‘。
		//但是，编译器都会确保空白final在使用前必须初始化。所以既然没在定义处初始化变量，那只能在构造函数里面进行处理了。
		this.id = id ;
	}
	private static Random rand = new Random(47) ;
	private final int valueOne = 9 ;
	private final int valueTwo = rand.nextInt(20) ;  //变量的值可以在编译时确定，也可以是运行时随机生成的值来初始化。
	static final int valueThree = rand.nextInt(20) ; //一个既是static又是final的变量只占据一段不能改变的内存空间。
	private final Value v1 = new Value(22) ;
	private final int valueFour ;
	
	public String toString(){
		return id + ": " + "valueTwo= " + valueTwo + ", valueThree = " + valueThree ;
	}
	public static void main(String[] args) {
		FinalData fd1 = new FinalData("fd1") ;
		//fd1.valueOne++ ;   // 对于基本数据类型而言，说明变量值不能改变
		//fd1.v1 = new Value(2) ;  //而对于对象引用类型而言，则说明变量不能被重新赋值，指向新的对象
        fd1.v1.i++ ; //但是变量所引用的对象却可以被修改
        
        System.out.println(fd1) ;
        System.out.println("Creating new FinalData") ;
        FinalData fd2 = new FinalData("fd2") ;
        System.out.println(fd1) ;
        System.out.println(fd2) ;
	}

}

       final方法：

                       1. 如果方法被定义成final（前提是方法没有用private修饰），那么子类不能覆盖该方法。

                        2.类中的private方法隐式的是final的，因为子类对private修饰的方法是不可见的。子类包含一个与超类中该private方法具有相同名称的方法，但这个不叫覆盖。

      final类：

                      1.如果一个类被定义成final，那么该类不能被继承。

                      2.如果一个类是final，那么也说明该类中的所有方法隐式的是final的，所以给方法添加final修饰词没有任何意义。但是，final类中的域可以不是final的，就是说可以改变new该类的对象的域的值。

     在JDK中出于安全等原因，有些类被设定成final类型，比如String ，StringBuffer，StringBuiler等。

      既然说到final，有谈到StringBuffer，String，当然要说2个概念immutable（不可变）以及mutable（可变的）。immutable 对象它的状态（比如对象数据）在它被初始化后就不能改变（你可以认为它就是一个只读的对象）。而String便是一个immutable对象，然而StringBuffer是一个线程安全的mutable类，StringBuiler是一个线程非安全的mutable类。那么如何写一个immutable类呢？

                     1. 类需要声明成final，这样不能被继承。

                     2. 所有的域被声明成final，这样在第一次赋值后，就不能改变了。

                     3. 类中不要提供任何改变immutable对象状态的方法，比如setXXX方法。

                     4.从获取器返回references to mutable object之前，先克隆（cloning）那些mutable object。

        下面展示一个例子：’    

package com.ebay;

public final class MyImmutable {
      private int[] myArray ;
      
      public MyImmutable(int[] anArray){
    	  this.myArray = anArray.clone() ;
      }
      
      public String toString(){
    	  StringBuffer sb = new StringBuffer("Numbers are:") ;
    	  for(int i = 0 ; i < myArray.length; i++){
    		  sb.append(myArray[i] + "") ;
    	  }
    	 
    	  return sb.toString() ;
      }
}

          当然谈到final，就会有finally以及finalize的不同运用场景了：

           final就不说了，finally是又在异常模块。处理特殊情况（比如System.exit(0)的调用），finally是异常处理一定执行的模块。一般我们用finally模块去关闭文件亦或是释放系统资源比如数据库连接等。而finalize（）主要运用于GC(垃圾回收).垃圾回收器会在回收无用的对象是调用该方法。

           在想想看，在object当中，有哪些方法是final的呢？wait（）、notify（）、notifyAll（）以及getClass（）都是。而像equals（）、hashCode（）、toString（）、clone（）以及finalize（）都是non-final方法。

               好了，先说到这里吧，有点晚了。