1. 基本介绍 393
final中文意思:最后的，最终的.
final可以修饰类、属性、方法和局部变量.
在某些情况下，程序员可能有以下需求，就会使用到final:
1)当不希望类被继承时,可以用final修饰. [案例演示]
2)当不希望父类的某个方法被子类覆盖/重写(override)时,可以用final关键字修饰。[案例演示: 访问修饰符final返回类型方法名]
3)当不希望类的的某个属性的值被修改，可以用final修饰.
4)当不希望某个局部变量被修改，可以使用final修饰
代码在com.stulzl.final_01.包中
Final01
package com.stulzl.final_01;
//final关键字 393
public class Final01 {
public static void main(String[] args) {
E e = new E();
//e.TAX_RATE=0.09;//此时因为TAX_RATE变量加了final不能修改
}
}
//要求A类不可以被任何其他类继承，可以使用final关键字
final class A{
}
//class B extends A{ }
//当不希望父类的某个方法被子类覆盖/重写(override)时,可以用final关键字修饰。
class C{
public final void hi(){ }
}
class D extends C{
// @Override
// public void hi() {//重写了C类中的hi方法
// super.hi();
// }
}
//当不希望类的的某个属性的值被修改，可以用final修饰.
class E{
public final double TAX_RATE = 0.08;
}
//当不希望某个局部变量被修改，可以使用final修饰
class F{
public void cry(){
final double num = 0.01;
//num = 0.9;//被final修饰不能修改
}
}2. final注意事项和细节
2.1 final细节01 394
1) final修饰的属性又叫常量，般用XX XX XX来命名
2) final修饰的属性在定义时，必须赋初值，并且以后不能再修改，赋值可以在如下位置之一[选择一个位置赋初值即可] :
①定义时:如public final double TAX_ RATE=0.08;
②在构造器中
③在代码块中。
3)如果final修饰的属性是静态的，则初始化的位置只能是
①定义时
②在静态代码块不能在构造器中赋值。
4) final类不能继承，但是可以实例化对象。
5)如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承。
代码在com.stulzl.final_detail.包中
FinalDetail01
package com.stulzl.final_detail;
//final 细节 394
public class FinalDetail {
public static void main(String[] args) {
CC cc = new CC();//final修饰的类可以被实例化
//如果类不是 final 类，但是含有 final 方法，则该方法虽然不能重写，但是可以被继承
//即，仍然遵守继承的机制.
EE ee = new EE();
ee.cal();
}
}
class AA{
/**
* final修饰的属性在定义时，必须赋初值
* ①定义时:如public final double TAX_ RATE=0.08;
* ②在构造器中
* ③在代码块中。
*/
public final double TAX_RATE=0.08;//定义直接赋值
public final double TAX_RATE2;
public final double TAX_RATE3;
//构造器中赋值
public AA() {
TAX_RATE2=1.1;
}
//代码块中赋值
{
TAX_RATE3=8.8;
}
}
class BB{
//如果final修饰的属性是静态的，则初始化的位置只能是
//①定义时
//②在静态代码块不能在构造器中赋值。
public static final double TAX_RATE = 99.9;
public static final double TAX_RATE2;
//在静态代码块中赋值
static{
TAX_RATE2=3.3;
}
}
//final类不能继承，但是可以实例化对象。
final class CC{
}
//如果类不是 final 类，但是含有 final 方法，则该方法虽然不能重写，但是可以被继承
//即，仍然遵守继承的机制.
class DD{
public final void cal(){
System.out.println("cal()方法……");
}
}
class EE extends DD{
}2.2 final细节02 395
5) 一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法。
6) final不能修饰构造方法(即构造器)
7) final和static往往搭配使用，效率更高，不会导致类加载....底层编译器做了优化处理。
8)包装类(Integer,Double,Float, Boolean等都是final),String也是final类。
代码在com.stulzl.final_detail02.包中
FinalDetail02
package com.stulzl.final_detail02;
//final 细节02 395
public class FinalDetail02 {
public static void main(String[] args) {
//只输出100 num被final修饰，不会导致BBB类的加载，
// 因此静态代码块不执行
System.out.println(BBB.num);
}
}
//final和static往往搭配使用，效率更高，不会导致类加载...底层编译器做了优化处理。
class BBB{
public final static int num=100;
static{
System.out.println("BBB静态代码块被执行……");
}
}
//一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法。
final class AAA{
//这里没必要再写final修饰方法了，
// 因为final类不能被继承，因此里面的方法更不会被重写
public final void hi(){}
}3. final关键字练习 396
3.1 关于final请编写一个程序，能够计算圆形的面积。要求圆周率为3.14.赋值的位置3个方式都写一下
代码在com.stulzl.final_exercise01.包中
FinalExercise01
package com.stulzl.final_exercise01;
//关于final，请编写一个程序，能够计算圆形的面积。要求圆周率为3.14.赋值的位置3个方式都写一下 396
public class FinalExercise01 {
public static void main(String[] args) {
circle circle = new circle(5.0);
System.out.println("面积="+circle.S());//调用
}
}
class circle{
private double radius;
private final double PI; //= 3.14;//定义直接赋值
//构造器赋值
public circle(double radius) {
//PI = 3.14;
this.radius = radius;
}
//代码块赋值
{
PI = 3.14;
}
//求面积方法
public double S(){
return PI*radius*radius;
}
}3.2 判断代码是否有误 396
public class Something{
public int addOne(final int x) { //下面的代码是否有误，为什么?
++x; //错误,原因是不能修改 final x 的值
return x + 1; //这里是可以. 因为x值没有被改变
}
}
代码在com.stulzl.final_exercise02.包中
FinalExercise02
package com.stulzl.final_exercise02;
public class FinalExercise02 {
public static void main(String[] args) {
Something something = new Something();
System.out.println(something.addOne(6));//7
}
}
class Something{
public int addOne(final int x) { //下面的代码是否有误，为什么?
//++x; //错误,原因是不能修改 final x 的值
return x + 1; //这里是可以. 因为x值没有被改变
}
}
