final

final 概述

用 final 修饰就表示不可以再被改变, 已经是最终的了.

final 可以修饰方法、类和变量.

用 final 修饰方法就表示这个方法是最终的方法, 不能被子类重写.

用 final 修饰一个类, 就表示这个类是最终的类, 不能被继承.

用 final 修饰变量, 则该变量应该被叫做常量, 只能被赋值一次且在被使用之前必须被赋值. 常量名的定义规范: 单个单词组成时, 所有字母大写. 多个单词组成时, 每个单词之间用下划线连接. 如: XXX_YYY_ZZZ.

final 修饰方法

下面的代码是未使用 final 时的情况:

class Fu {
    public void show() {
        System.out.println("父类的show方法. ");
    }
}
 
// Zi 继承 Fu
class Zi extends Fu {
// 重写 Fu 的 show()
    public void show() {
        System.out.println("子类的show方法. ");
    }
}

添加 final 修饰方法时:

class Fu {
    public final void show() {
        System.out.println("父类的show方法. ");
    }
}
 
class Zi extends Fu {
    public void show() {  // 报错, 显示 'show()' cannot override 'show()' in 'demo.Fu'; overridden method is final
        System.out.println("子类的show方法. ");
    }
}

如果一个方法是一个规则, 我不希望别人去改变, 那此时这个方法就可以用 final 去修饰.

final 修饰类

未使用 final 时的继承情况, 此时程序正确:

class Fu {
}
 
class Zi extends Fu {
}

使用了 final 之后:

final class Fu {
}
 
class Zi extends Fu {  // 报错, 显示 can not inherit from final Fu
}

String 类就是用 final 修饰的:

图 1

final 修饰常量

使用 final 修饰基本数据类型的变量的情况:

public static void main(String[] args) {
    final int a = 20;
    a = 10;  // 报错: cannot assign a value to final variable 'a'
}

public static void main(String[] args) {
    final int a;                // 不使用 a 时不对 a 进行赋值是不会报错的
    System.out.println(a);      // 报错: Variable 'a' might not have been initialized
}

再例如, 下面这两个被 final 修饰的变量 (其实应该叫常量) 在 Math 类中:

public static final double E = 2.7182818284590452354;
public static final double PI = 3.14159265358979323846;

实际开发中, 常量一般都是作为系统的配置信息, 方便维护, 提高代码的可读性.

用 final 修饰的常量, 如果是基本数据类型, 那么存储的数据值是不能发生改变的.

用 final 修饰的常量, 如果是引用数据类型, 那么存储的地址值不能发生改变, 但是对象内部的值可以改变.

程序示例:

public static void main(String[] args) {
    final Student S = new Student("zhangsan", 23);  // 用 final 修饰一个引用数据类型
    S.setAge(24);                 // 对象内部的值可以改变
    S.setName("lisi");            // 对象内部的值可以改变
    System.out.println(S.getAge() + ", " + S.getName());  // 24, lisi
 
    S = new Student();  // 报错: cannot assign a value to final variable 'S'
}

程序示例:

public static void main(String[] args) {
    final int[] ARR = {1, 2, 3, 4};  // 用 final 修饰一个引用数据类型
    ARR[0] = 20;                     // 对象内部的值可以改变
    ARR[1] = 10;                     // 对象内部的值可以改变
    for (int i = 0; i < ARR.length; i++) {
        System.out.print(ARR[i] + "    ");    // 20    10    3    4
    }
    ARR = new int[3];    // 报错: cannot assign a value to final variable 'ARR'
}

const 是 Java 保留的关犍字, 但目前并没有使用. 在 Java 中, 必须使用 final 声明常量.

final 修饰的常量可以放在 switch 语句的 case 后面.

在 Java 中, 可能经常需要创建一个常量以便在一个类的多个方法中使用. 通常将这些常量称为类常量 (class constant). 可以使用关键字 static final 设置一个类常量. 类常量可以是公有或私有都行, 要看具体程序的要求. 静态成员变量可以被静态或者非静态的方法访问, 用途更加广泛.

程序示例:

public class Test {
    public static final int a = 10;     // 声明了一个公有的类常量
    // 类常量要定义在所在类的所有的方法外面, 包括 main 方法 (如果是定义在一个含有 main 方法的测试类的话) 
    // 这里的类常量是公有的, 所以其他类也可以用这个常量. 
}

字符串的内容不可变:

数组 value 用来存储字符串的内容:

图 2

可见, 数组存储的是字节, 因为 value 是用 final 修饰的, 所以 value 保存的地址值是不能发生改变的. 由于有 private 修饰符, 所以在外界是无法获取到 value 的值的, 也就是获取不到这个数组的地址. 并且 String.java 没有提供对 value 的 get 和 set 方法.

图 3

所以在外界不能获取到 value 记录的地址值.

这里是用 final 和 private 两个关键字结合起来使得字符串不能发生改变.