Java中final作用于變量、參數(shù)、方法及類該如何處理

class Value{
 int i;
 public Value(int i){
  this.i = i;
 }
}

public class FinalData {
 private static Random random = new Random(47);
 private String id;
 
 public FinalData(String id){
  this.id = id;
 }
 
 private final int valueOne = 9;
 private static final int VALUE_TWO = 99;
 public static final int VALUE_THREE = 39;
 private final int i4 = random.nextInt(20);
 static final int INT_5 = random.nextInt(20);
 
 private Value v1 = new Value(11);
 private final Value v2 = new Value(22);
 private static final Value VAL_3 = new Value(33);
 
 private final int[] a = {1, 2, 3, 4, 5, 6};
 public String toString(){
  return id + ": " + "i4 = " + i4 + ", INT_5 = " + INT_5;
 }
 
  public static void main(String[] args) {
  FinalData fd1 = new FinalData("fd1");
  //! fd1.valueOne++; // 因為valueOne是基本類型常量，其數(shù)值恒定不變
  fd1.v2.i++; //final修飾的對象的內(nèi)容可以改變
  fd1.v1 = new Value(9);
  for(int i = 0; i < fd1.a.length; i++)
   fd1.a[i]++;
  //! fd1.v2 = new Value(0); // 因為v2是final修飾的引用類型，其引用不能被修改指向另一個對象
  //! fd1.VAL_3 = new Value(1); // 表示占據(jù)一段不能改變的內(nèi)存空間
  //! fd1.a = new int[3]; // final修飾的數(shù)組
  System.out.println(fd1);
  System.out.println("Creating new FinalData");
  FinalData fd2 = new FinalData("fd2");
  System.out.println(fd1);
  System.out.println(fd2);
 }
}
/*output:
fd1: i4 = 15, INT_5 = 18
Creating new FinalData
fd1: i4 = 15, INT_5 = 18
fd2: i4 = 13, INT_5 = 18
*/

class Gizmo{
 int i = 0;
 public void spin(){}
}
public class FinalArguments {
 void with(final Gizmo g){
  //! g = new Gizmo(); // 無法修改final修飾的引用，使它指向另一個對象
  g.i++; // 但可以修改final對象所指向的內(nèi)容
 }
 void without(Gizmo g){
  g = new Gizmo();
  g.spin();
 } 
// int g(final int i){
//  //! i++; //因為參數(shù)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);
 }
}

class WithFinals{
 private final void f(){
  System.out.println("WithFinals.f()");
 }
 private void g(){
  System.out.println("OverridingPrivate.f()");
 }
}
class OverridingPrivate extends WithFinals{
 private final void f(){
  System.out.println("OverridingPrivate.f()");
 }
 private void g(){
  System.out.println("OverridingPrivate.g()");
 }
}
class OverridingPrivate2 extends OverridingPrivate{
 /*
  * 當使用Override注解強制使f()方法覆蓋父類的f()方法時，會報錯
  * 因為它不知道父類是否有該方法，對于g()方法來說，它只是生成了一個新的方法，
  * 并沒有覆蓋掉父類中的g()方法。
  */
 //@Override
 public final void f(){
  System.out.println("OverridingPrivate2.f()");
 }
 public void g(){
  System.out.println("OverridingPrivate2.g()");
 }
}
public class FinalOverridingIllusion{
 public static void main(String[] args) {
  OverridingPrivate2 op2 = new OverridingPrivate2();
  op2.f();
  op2.g();
  
  // 可以向上轉(zhuǎn)型
  OverridingPrivate op = op2;
  //! op.f(); // 父類中final方法對子類來說是不可見的
  //! op.g();
  WithFinals wf = op2;
  // wf.f();
  // wf.g();
 }
}
/*output:
OverridingPrivate2.f()
OverridingPrivate2.g()
*/

class SmallBrain{}
final class Dinosaur{
 int i = 7;
 int j = 1;
 SmallBrain x = new SmallBrain();
 void f(){}
}
// error: The type Further cannot subclass the final class Dinosaur
// Dinosaur類不能有子類
// class Further extends Dinosaur{}
public class Jurassic {
 public static void main(String[] args) {
  Dinosaur n = new Dinosaur();
  n.f();
  n.i = 40;
  n.j++;
 }
}