public class Value
{
    int i=1;
}

public class FinalData
{
    final int i1 = 9;
    static final int I2 = 99;
    public static final int I3 = 39;
    final int i4 = (int)(Math.random()*20);//特别注意
    static final int i5 = (int)(Math.random()*20);//特别注意
    Value v1 = new Value();
    final Value v2 = new Value();
    static final Value v3 = new Value();
    final int[] a = { 1, 2, 3, 4, 5, 6 };
    public void print(String id)
    {
        System.out.println(id + ": " + "i4 = " + i4 + ", i5 = " + i5);
    }

    public static void main(String[] args)
    {
        FinalData fd1 = new FinalData();
       //! fd1.i1++; // Error:final的值不能被改变
        fd1.v2.i++; // 对象的成员未被设成final，不会报错
        fd1.v1 = new Value(); // OK --不是final对象
        for(int i = 0; i < fd1.a.length; i++)
            fd1.a[i]++; // 对象的成员未被设成final，不会报错
           // fd1.v2 = new Value(); // Error: Can‘t
           // fd1.v3 = new Value(); // 不能将一个final引用指向另一个
           // fd1.a = new int[3];
        fd1.print("fd1");
        System.out.println("Creating new FinalData");
        FinalData fd2 = new FinalData();
        fd1.print("fd1");
        fd2.print("fd2");
    }
}

 

Java强行要求我们对 final 进行赋值处理—— 要么在定义字段时使用一个表达 式，要么在每个构建器中。这样就可以确保 final 字段在使用前获得正确的初始化。 

1、为方法“上锁”，防止任何继承类改变它的本来含义。设计程序时，若希望一个方法的行为在继承期间保持不变，而且不可被覆盖或改写，就可以采取这种做法。

2、将一个方法设成 final 后，编译器就可以把对那个方法的所有调用都置入“嵌入”调用里。只要编译器发现一个 final 方法调用，就会（根据它自己的判断）忽略为执行方法调用机制而采取的常规代码插入方法（将自变量压入堆栈；跳至方法代码并执行它；跳回来；清除堆栈自变量；最后对返回值进行处理）。相反，它会用方法主体内实际代码的一个副本来替换方法调用。这样做可避免方法调用时的系统开销。当然，若方法体积太大，那么程序也会变得雍肿，可能受到到不到嵌入代码所带来的任何性能提升。因为任何提升都被花在方法内部的时间抵消了。 Java 编译器能自动侦测这些情况，并颇为“明智”地决定是否嵌入一个 final 方法。然而，最好还是不要完全相信编译器能正确地作出所有判断。通常，只有在方法的代码量非常少，或者想明确禁止方法被覆盖的时候，才应考虑将一个方法设为final。

    类内所有 private 方法都自动成为 final。由于我们不能访问一个 private 方法，所以它绝对不会被其他方法覆盖。