1.1 final数据

1.一个永不改变的编译时常量
2.一个在运行时被初始化的值，而你不希望它被改变

在Java中，这类常量必须是基本数据类型，并且以关键字final表示。在这个常量进行定义的时候，必须对其进行赋值

一个既是static又是final的域只占据一段不能改变的储存空间

当对对象引用而不是基本数据类型运用final时。对于基本类型，final使数值恒定不变；而用于对象引用，final使引用恒定不变。这一限制同样适用于数组，它也是对象。

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 = 29;
    public static final int VALUE_THREE = 39;
    private final int ir = random.nextInt(20);
    static final int INT = random.nextInt(20);
    private Value v1 = new Value(1);
    private final Value v2 = new Value(2);
    private static final Value V3 = new Value(3);
    private final int[] a = {1, 2, 3, 4, 5, 6};

    @Override
    public String toString() {
        return "FinalData{" +
                "id='" + id + '\'' +
                ", ir=" + ir + ", INT =" + INT +
                '}';
    }

    public static void main(String[] args) {
        FinalData fd1 = new FinalData("fd1");
//        fd1.valueOne++;   //Error:valueOne为final,值不能改变
        fd1.v2.i++;
        fd1.v1 = new Value(9);
        for (int i = 0; i < fd1.a.length; i++)
            fd1.a[i]++;

//        fd1.v2 = new Value(0);    //Error
//        fd1.a = new int[3];       //Error
        System.out.println(fd1);
        System.out.println("Creating new FinalData");
        FinalData fd2 = new FinalData("fd2");
        System.out.println(fd1);
        System.out.println(fd2);
    }
}

运行结果：

FinalData{id='fd1', ir=15, INT =18}
Creating new FinalData
FinalData{id='fd1', ir=15, INT =18}
FinalData{id='fd2', ir=13, INT =18}

1.我们不能因为数据是final的就认为在编译时可以知道它的值，在运行时使用随机生成的数值来初始化ir和INT就说明了这点。

2.示例部分展示了将final数值定义为静态和非静态的区别。在fd1和fd2中，ir的值是唯一的(这里的唯一是对于对应的引用)，但INT的值是不可以通过创建第二个FinalData对象来改变的,因为它是static的，在装载时已被初始化，而不是每次创建新对象时都会初始化。(静态初始化动作，这段代码仅执行一次)

1.2 空白final

Java允许生成“空白final”,空白final指被声明为final但又未给定初值的域。无论在何种情况下，编译器都要确保空白final使用前必须被初始化。

class Poppet {
    public int i;

    Poppet(int ii) {
        i = ii;
    }
}

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

    public BlankFinal() {
        j = 1;
        p = new Poppet(1);
        System.out.println("j = " + j + ",p.i =" + p.i);
    }

    public BlankFinal(int x) {
        j = x;
        p = new Poppet(x);
        System.out.println("j = " + j + ",p.i =" + p.i);
    }

    public static void main(String[] args) {
        new BlankFinal();
        new BlankFinal(2);
    }
}

输出结果：

j = 1,p.i =1
j = 2,p.i =2

必须在域的定义外或者每个构造器用表达式对final进行赋值，这正是final域在使用前总是被初始化的原因所在。

1.2.1 域的定义

class bike{ 
  static int bikes;
  int gear;
  int cadence;

  void create( int newGear, int newCadence ){
    bikes = bikes + 1;
    gear = newGear;
    cadence = newCadence;
  }
  
  int getSpeed(){
    int speed = gear*cadence*5*3.141;
    return speed;
  }
}

bikes是一个类变量(静态域)
gear 和 cadence 是对象变量（实例变量）（非静态域）

这里有一点点小矛盾，其实这样照百科这样说，那么bikes、gear和cadence都是类变量，bikes是类变量中的静态变量，而gear和cadence是类变量中的实例变量

speed是对象方法的变量(局部变量)。

java没有出现local variable->局部变量，gobal variable->全局变量，要说的话类变量的作用范围和全局变量一样，只不过不那样叫。中文翻译的问题

newGear和newCadence是函数(方法)的参数(参数)。

1.3 final参数

Java允许在参数的列表中以声明的方式将参数指名为final。意味着我们无法在方法中更改参数引用所指向的对象。

class Args{
    public void arg(){

    }
}

public class FinalArguments {
    void with(final Args args){
//        args = new Args();       Error:args is final
    }

    void without(Args args){
        args = new Args();
        args.arg();
    }

    void f(final int i){
//        i++;              Error:can't change,i is final
    }

    //final类型的参数只可以读,无法修改参数
    int g(final int i){
        return i + 1;
    }

    public static void main(String[] args) {
        FinalArguments finalArguments = new FinalArguments();
        finalArguments.without(null);
        finalArguments.with(null);
        System.out.println(finalArguments.g(1));
    }
}

方法f()和g()展示了当基本类型的参数被指明为fianl时：可以读参数，无法修改参数。这一特性主要用来向匿名内部类传递数据。