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时：可以读参数，无法修改参数。这一特性主要用来向匿名内部类传递数据。
1.4 final方法
将方法指定为fianl，可以将方法锁定，以防止任何继承类修改，并且不会被覆盖。
1.5 final类
当某个类整体被定义为final时，表明你不希望继承该类，不希望它有子类。
