Think in Java——static与final

public class FinalData {
    private static Random rand = new Random(47);
    private String id;

    FinalData(String id) {
        this.id = id;
    }

    private final int i4 = rand.nextInt(20);
    static final int i5 = rand.nextInt(20);

    public String toString() {
        return id + ": " + "i4 = " + i4 + "i5 = " + i5;
    }
}

public class Main {

    public static void main(String[] args) {
        FinalData fd1=new FinalData("fd1");
        System.out.println(fd1.toString());
        FinalData fd2=new FinalData("fd2");
        System.out.println(fd2.toString());
    }
}

 输出为

fd1: i4 = 15i5 = 18
fd2: i4 = 13i5 = 18

我们看到fd1和fd2中的i4字段虽然由final修饰，但它们并不相同，这是因为i4在对象创建时才初始化。i5字段不会因为创建第二个FinalData对象而改变。这是因为它是static的，在类装载时已经被初始化，而不是每次创建对象时初始化。

关于final引用

public class FinalData2 {
    public Value b=new Value(4);
    public final Value a=b;

}

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

public class Main {

    public static void main(String[] args) {
        FinalData2 fd = new FinalData2();
        System.out.println("最初 "+fd.a.value);
        fd.b.value=7;
        System.out.println("修改fd.b.value "+fd.a.value);
        fd.b=new Value(8);
        System.out.println("修改引用b之后 "+fd.a.value);
        fd.a.value=9;
        System.out.println("将fd.a.value修改后 "+fd.a.value);
    }


}

输出结果

最初 4
修改fd.b.value 7
修改引用b之后 7
将fd.a.value修改后 9

可见不能认为因为a是final的就无法改变它的值。由于它是一个引用，final意味着a无法指向另一个新的对象，但a指向的对象是可以改变的。

空白final

空白final指被声明为final但又未给定初值的域。java允许空白final存在，但编译器会确保空白final在使用前必须被初始化。

public class BlankFinal {
    private final int i=0;
    private final int j;
    private final Poppet p;

    public BlankFinal(){
        j=1;
        p=new Poppet();
    }

    public BlankFinal(int x){
        j=x;
        p=new Poppet();// 如果注释掉这行，编译器就会报错 Error: java: 可能尚未初始化变量p
    }
}

 

被public final修饰的方法无法覆盖。但private final修饰的方法可以“覆盖”，但此时并不是覆盖，仅是生产了一个新的方法。

final加在类上 此类无法被继承

final加在非引用字段上，字段的内容无法改变

final加在引用上，引用无法指向新的对象

final加在方法上，此方法无法被重载