java—final变量、方法、类

final数据

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

class FinalData{
    public static Random rand = new Random(47);
    public String id;
    public FinalData(String id){
        this.id = id;
    }
    public final int valueOne = 9;
    public static final int VALUE_TWO = 99;
    public static final int VALUE_THREE = 39;
    public final int i4 = rand.nextInt(20);
    static final int INT_5 = rand.nextInt(20);
    public Value v1 = new Value(11);
    public final Value v2 = new Value(22);
    public static final Value VAL_3 = new Value(33);

    public final int[] a = {1, 2, 3, 4, 5, 6};

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




public class Main {

    public static void main(String[] args) throws InterruptedException {
        FinalData fd1 = new FinalData("fd1");
        //fd1.valueOne++;   //不能改变基本final变量的值
        fd1.v2.i++;       //v2为静态变量，指的是它引用的哪个对象不能改变，而引用的那个对象中的非final基本类型i能改变
        fd1.v1 = new Value(9);   //非final
        for(int i = 0; i < fd1.a.length; i++){          //同v2
            fd1.a[i]++;
        }
//        fd1.v2 = new Value(0);              //can't change reference
//        fd1.VAL_3 = new Value(1);
//        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);
    }
}

运行结果：

 

        当用final去修饰基本数据类型时，数据被初始化后，不能改变数据的值；被final修饰的对象引用，不能改变它引用的对象，而它引用的对象中的非final数据，可以被修改。同样，static修饰的数据，只能被初始化一次，如INT_5；而非static的final数据，随新对象的创建，会被重新初始化，而后不能改变它的值。

 空白final数据：那么必须在构造方法中对其初始化，如果有多个构造方法，则每个方法都要对其初始化

class Poppet{
    private int i;
    Poppet(int i){
        this.i = i;
    }
}

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

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

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

}

public class Main {

    public static void main(String[] args) throws InterruptedException {
        new BlankFinal();
        new BlankFinal(20);
    }
}

final方法

  被final方法修饰的去修饰方法，有两个作用：

 1）该方法被锁定，任何继承类都不能覆盖它，private方法隐式为final修饰

  2）final方法会被内嵌调用

final类

     被final修饰的类，不能被继承，因为不能被继承，则类中的方法默认为final。