java 关键字 final

1. final 数据

package com.lgf.keyword;
/**
 * 测试类
 * @author lgf
 */
class Value {
  int i; 
  public Value(int i) 
  { 
	  this.i = i; 
  }
}

/**
 * @author lgf
 * 一个永不改变的编译时常量
 * 一个在运行时候被初始化,并且不希望值被改变
 * 
 * 对于基本类型,final使得数值恒定不变
 * 对于对象引用,final使得引用恒定不变(引用)
 */
public class FinalData {
  private String id;
  public FinalData(String id) 
  { 
	  this.id = id; 
  }
  private final int valueOne = 9;
  private final static int VALUE_TWO = 99;
  
//  final对象
  private final Value valueObjFinal = new Value(22);

  // Arrays:
  private final int[] a = { 1, 2, 3, 4, 5, 6 };
  
  public static void main(String[] args) {
	FinalData finalData = new FinalData("fd1");
	//! finalData.valueOne++; //Error: valueOne 为final对象,无法进行修改
	System.out.println("FinalData.VALUE_TWO = " + FinalData.VALUE_TWO);
	
	System.out.println("finalData.valueObjFinal.i = " + finalData.valueObjFinal.i);
//	valueObjFinal 对象是静态的,当是对象成员不是静态的
    finalData.valueObjFinal.i++; // 
    System.out.println("finalData.valueObjFinal.i = " + finalData.valueObjFinal.i);
//  ! finalData.valueObjFinal = new Value(0);// final 对象不能修改其引用
    
//    对数组也是引用
    for(int i = 0; i < finalData.a.length; i++){
    	finalData.a[i]++; // Object isn't constant! 可以修改其值
    }
    //! finalData.a = new int[3]; // 不能修改其引用
  }
} 

package com.lgf.keyword;
/**
 * 可以在生成对象时候在进行定义final的值
 * 但是在构造函数中必须进行赋值
 * 实际使用前得到正确的初始化
 * @author lgf
 */
public class FinalBlank {
  private final int i = 0; // 进行初始化
  private final int j; // 不初始化
  
  /**
   * 该类中存在未初始化的final参数,必须在构造函数中初始化
   */
  public FinalBlank() {
	j = 1; 
  }
  public FinalBlank(int x) {
    j = x; // Initialize blank final
  }
  public static void main(String[] args) {
	FinalBlank blankFinal = new FinalBlank();
	FinalBlank blankFinal2 = new FinalBlank(47);
    System.out.println("blankFinal.j = " + blankFinal.j);
    System.out.println("blankFinal.j = " + blankFinal2.j);
  }
} 

2. final 方法参数

package com.lgf.keyword;

class Gizmo {
  public void spin() {}
}

/**
 * 可以对方法的参数设置为final
 * 保证其不会被修改
 * @author lgf
 *
 */
public class FinalArguments {
  void with(final Gizmo g) {
    //! g = new Gizmo(); // g 是final的,不能在方法中进行修改
  }
  void without(Gizmo g) {
    g = new Gizmo(); // g 不是是final的,能在方法中进行修改
    g.spin();
  }
   void f(final int i) { 
//	   i++; // Can't change
   } 
  // 不能对i的值进行修改.仅仅可以对其进行使用
  int g(final int i) { 
	  return i + 1; 
  }
  public static void main(String[] args) {
    FinalArguments bf = new FinalArguments();
    bf.without(null);
    bf.with(null);
  }
}

3. overriding

package com.lgf.keyword;

class WithFinalFunction {
  // Identical to "private" alone:
	private final void f() { 
		System.out.println("WithFinalFunction.f()"); 
	}
	// Also automatically "final":
	private void g() { 
		System.out.println("WithFinalFunction.g()"); 
	}
}

/**
 * 下面的f  和 g 方法都不是进行overwrite
 * 而是单纯的重新定义新的方法 f 和 g 方法
 * @author lgf
 */
class OverridingPrivate extends WithFinalFunction {
	public final void f() {
		System.out.println("OverridingPrivate.f()");
	}
	public void g() {
		System.out.println("OverridingPrivate.g()");
	}
}


class OverridingPrivateChildern extends OverridingPrivate {
	
//	无法overwrite final方法
//	public final void f() {
//		System.out.println("OverridingPrivate2.f()");
//	}
	public void g() {
		System.out.println("OverridingPrivateChildern.g()");
	}
}

public class FinalOverridingIllusion {
	public static void main(String[] args) {
		OverridingPrivateChildern op2 = new OverridingPrivateChildern();
	    op2.f();
	    op2.g();
	    OverridingPrivate op = op2;
	    op.f();
	    op.g();
	    WithFinalFunction wf = op2;
	    //wf.f();
	    //! wf.g();
	}
} 

4. final class

package com.lgf.keyword;
/**
 * 类内所有 private 方法都自动成为 final。
 * @author lgf
 */
final class Dinosaur {
  int i = 7;
  int j = 1;
  private void privateFunction() {}
  public void publicFunction() {}
}

/**
 *final类无法被继承
 * @author lgf
 */
//! class Further extends Dinosaur {}
// error: Cannot extend final class 'Dinosaur'