package finalPackage;
import java.util.*;
class Value {
  int i;
  public Value(int i) {
    this.i = i;
  }
}
/**
 * final數(shù)據(jù)常量
 * @author Administrator
 * 對(duì)基本類型使用final不能改變的是它的數(shù)值。
 * 而對(duì)于對(duì)象引用，不能改變的是他的引用，而對(duì)象本身是可以修改的。
 * 一旦一個(gè)final引用被初始化指向一個(gè)對(duì)象，這個(gè)引用將不能在指向其他對(duì)象。 
 * 注意，根據(jù)慣例，即是static又是final的域(即編譯器常量)將用大寫表示，并用下劃分割個(gè)單詞。
 */
public class FinalData {
  private static Random rand = new Random(47);
  private String id;
  public FinalData(String id) {
    this.id = id;
  }
  // 編譯時(shí)常量 Can be compile-time constants:
  private final int valueOne = 9;
  private static final int VALUE_TWO = 99;
  // 典型的公共常量 Typical public constant:
  public static final int VALUE_THREE = 39;
  // 運(yùn)行時(shí)常量 Cannot be compile-time constants:
  private final int i4 = rand.nextInt(20);
  static final int INT_5 = rand.nextInt(20);
  private Value v1 = new Value(11);
  private final Value v2 = new Value(22);
  private static final Value VAL_3 = new Value(33);
  // 數(shù)組 Arrays:
  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++; // Error: can't change value
    fd1.v2.i++; // Object isn't constant!
    fd1.v1 = new Value(9); // OK -- not final
    for (int i = 0; i < fd1.a.length; i++)
      fd1.a[i]++; // Object isn't constant!
    // ! fd1.v2 = new Value(0); // Error: Can't
    // ! fd1.VAL_3 = new Value(1); // change reference
    // ! fd1.a = new int[3];
    System.out.println(fd1);
    System.out.println("Creating new FinalData");
    FinalData fd2 = new FinalData("fd2");
    System.out.println(fd1);
    System.out.println(fd2);
  }
  /**
   * 輸出結(jié)果：
   * fd1: i4 = 15, INT_5 = 18
   * Creating new FinalData
   * fd1: i4 = 15, INT_5 = 18
   * fd2: i4 = 13, INT_5 = 18
   */
}

package finalPackage;
class Poppet {
  private int i;
  Poppet(int ii) {
    i = ii;
  }
  public int getI() {
    return i;
  }
  public void setI(int i) {
    this.i = i;
  }
}
/**
 * 空白final
 * @author Administrator
 * 所謂空白final是指被聲明為final但又未給初值的域。無論什么情況下編譯器都會(huì)保證final域在使用前初始化。
 */
public class BlankFinal {
  private final int i = 0; // Initialized final
  private final int j; // Blank final
  private final Poppet p; // Blank final reference
  // Blank finals MUST be initialized in the constructor:
  public BlankFinal() {
    j = 1; // Initialize blank final
    p = new Poppet(1); // Initialize blank final reference
  }
  public BlankFinal(int x) {
    j = x; // Initialize blank final
    p = new Poppet(x); // Initialize blank final reference
  }
  public static void main(String[] args) {
    BlankFinal b1=new BlankFinal();
    BlankFinal b2=new BlankFinal(47);
    System.out.println("b1.j="+b1.j+"\t\t b1.p.i="+b1.p.getI());
    System.out.println("b2.j="+b2.j+"\t\t b2.p.i="+b2.p.getI());
  }
  /**
   * 輸出結(jié)果：
   * b1.j=1     b1.p.i=1
   * b2.j=47     b2.p.i=47
   */
} 

package finalPackage;
class Gizmo {
  public void spin(String temp) {
    System.out.println(temp+" Method call Gizmo.spin()");
  }
}
/**
 * final參數(shù)
 * @author Administrator
 * 如果將參數(shù)列表中的參數(shù)指明為final，這意味著你無發(fā)改變參數(shù)所指向的對(duì)象的引用。
 */
public class FinalArguments {
  void with(final Gizmo g) {
    // ! g = new Gizmo(); // Illegal -- g is final
  }
  void without(Gizmo g) {
    g = new Gizmo(); // OK -- g not final
    g.spin("without");
  }
  // void f(final int i) { i++; } // Can't change
  // You can only read from a final primitive:
  int g(final int i) {
    return i + 1;
  }
  public static void main(String[] args) {
    FinalArguments bf = new FinalArguments();
    bf.without(null);
    bf.with(null);
    System.out.println("bf.g(10)="+bf.g(10));
  }
  /**
   * 輸出結(jié)果：
   * withoutMethod call Gizmo.spin()
   * bf.g(10)=11
   */
} 

package finalPackage;
/**
 * final和private關(guān)鍵字 
 * 
 * 類中的所有private方法都是隱式的制定為final的。
 * 由于你無法訪問private方法，所以你也就無法覆蓋它。
 * 可以對(duì)private方法添加final修飾詞，但這毫無意義。
 */
class WithFinals {
  // Identical to "private" alone:
  private final void f() {
    System.out.println("WithFinals.f()");
  }
  // Also automatically "final":
  private void g() {
    System.out.println("WithFinals.g()");
  }
}
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 {
  public final void f() {
    System.out.println("OverridingPrivate2.f()");
  }
  public void g() {
    System.out.println("OverridingPrivate2.g()");
  }
}
public class OverideFinal {
  public static void main(String[] args) {
    WithFinals w1 = new WithFinals();
    // ! w1.f(); //Error，無法訪問私有方法
    // ! w1.g(); //Error，無法訪問私有方法
    OverridingPrivate w2 = new OverridingPrivate();
    // ! w2.f(); //Error，無法訪問私有方法
    // ! w2.g(); //Error，無法訪問私有方法
    OverridingPrivate2 w3 = new OverridingPrivate2();
    w3.f();
    w3.g();
  }
  /**
   * 輸出結(jié)果：
   * OverridingPrivate2.f()
   * OverridingPrivate2.g()
   */
}

package finalPackage;
class SmallBrain {
}
final class Dinosaur {
  int i = 7;
  int j = 1;
  SmallBrain x = new SmallBrain();
  void f() {
    System.out.println("Dinosaur.f()");
  }
}
// ! class Further extends Dinosaur {}
// error: Cannot extend final class 'Dinosaur'
/**
 * final 類
 * 
 * final類中的屬性可以選擇是否定義為final
 * final類中的方法都隱式的制定為final方法，因此你無法覆蓋他們
 */
public class Jurassic {
  public static void main(String[] args) {
    Dinosaur n = new Dinosaur();
    n.f();
    n.i = 40;
    n.j++;
    System.out.println("n.i="+n.i);
    System.out.println("n.j="+n.j);
  }
  /**
   * 輸出結(jié)果為：
   * Dinosaur.f()
   * n.i=40
   * n.j=2
   */
}