1 基本介绍

final中文意思:最后的,最终的.
final可以修饰类、属性、方法和局部变量.
在某些情况下,程序员可能有以下需求，就会使用到final:

1)当不希望类被继承时,可以用final修饰.

2)当不希望父类的某个方法被子类覆盖/重写(override)时,可以用final关键字修饰。

【案例演示: 访问修饰符 final 返回类型 方法名】

3)当不希望类的的某个属性的值被修改,可以用final修饰.【案例演示:publicfinal double TAX_RATE=0.08】

4)当不希望某个局部变量被修改，可以使用final修饰【案例演示: final double TAX RATE=0.08 )

public class Final01 {
    public static void main(String[] args) {
        E e = new E();
        //e.TAX_RATE = 0.09;
    }
}

//如果我们要求A类不能被其他类继承
//可以使用final修饰 A类
final class A { }

//class B extends A {}

class C {
    //如果我们要求hi不能被子类重写
    //可以使用final修饰 hi方法
    public final void hi() {}
}
class D extends C {
//    @Override
//    public void hi() {
//        System.out.println("重写了C类的hi方法..");
//    }
}

//当不希望类的的某个属性的值被修改,可以用final修饰
class E {
    public final double TAX_RATE = 0.08;
}

//当不希望某个局部变量被修改，可以使用final修饰
class F {
    public void cry() {
        //这时，NUM 也称为 局部常量
        final double NUM = 0.01;
        //NUM = 0.9;
        System.out.println("NUM=" + NUM);
    }
}

2 final 使用注意事项

1. final修饰的属性又叫常量,一般用XX_XX_XX来命名;

2. final修饰的属性在定义时,必须赋初值,并且以后不能再修改，赋值可以在如下位置之一【选择一个位置赋初值即可】:
   ①定义时:如public final double TAX_RATE=0.08;

​ ②在构造器中；

​ ③在代码块中。

3)如果final修饰的属性是静态的，则初始化的位置只能是

​ ①定义时,

​ ②在静态代码块,不能在构造器中赋值。

4. final类不能继承,但是类可以实例化对象。[A2类]

5)如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承。[A3类]

6)一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法。

7. final不能修饰构造方法(即构造器);

8. final 和 static往往搭配使用，效率更高，不会导致类加载，因为底层编译器做了优化处理。

9)包装类(Integer,Double,Float，Boolean等都是final),String也是final类。

public class FinalDetail01 {
    public static void main(String[] args) {
        CC cc = new CC();

        new EE().cal();
    }
}

class AA {
    /*
    1. 定义时：如 public final double TAX_RATE=0.08;
    2. 在构造器中
    3. 在代码块中
     */
    public final double TAX_RATE = 0.08;//1.定义时赋值
    public final double TAX_RATE2 ;
    public final double TAX_RATE3 ;

    public AA() {//构造器中赋值
        TAX_RATE2 = 1.1;
    }
    {//在代码块赋值
        TAX_RATE3 = 8.8;
    }
}

class BB {
    /*
    如果final修饰的属性是静态的，则初始化的位置只能是
    1 定义时  2 在静态代码块 不能在构造器中赋值。
     */
    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 { }

public class FinalDetail02 {
    public static void main(String[] args) {
        System.out.println(BBB.num);

        //包装类,String 是final类，不能被继承

    }
}

//final 和 static 往往搭配使用，效率更高，不会导致类加载.底层编译器做了优化处理
class BBB {
    public final static  int num = 10000;
    static {
        System.out.println("BBB 静态代码块被执行");
    }
}
final class AAA{
    //一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法
    //public final void cry() {}
}

3 练习（易错）