Java超详细分析讲解final关键字的用法

package com.demo.final_;
public class final01 {
    public static void main(String[] args) {
        E e=new E();
        e.n1=5.66;
        //e.n2=6.88;//ERROE
    }
}
//如果要求A类不能被其它类继承
//可以使用final修饰A类
final class A{ }
//class B extends A{}//ERROR
// 2)当不希望父类的某个方法被子类覆盖/重写(override)时,可以用final关键字 修饰。
class C{
    //如果我们要求hi不能被重写
    //使用final修饰
    public void hi(){}
    public final void hi01(){}
}
class D extends C{
    @Override
    public void hi() {
        super.hi();
    }
   /* @Override
    public void hi01() {
        super.hi01();
    }*///ERROR
}
//3)当不希望类的的某个属性的值被修改,可以用final修饰
class E{
    public double n1=1.99;
    public final double n2=2.88;
}
//4)当不希望某个局部变量被修改，可以使用final修饰
class F{
    public void cry(){
        final double s1=0.2;
        //此时s1被称为局部常量
        //s1=1.4;//ERROR
        double s2=0.8;
        s2=5.6;
    }
}

package com.demo.final_;
public class final_detials {
    public static void main(String[] args) {
        CC c=new CC();
        FF f=new FF();
    }
}
/*
    > 1) final修饰的属性又叫常量,一般用 XX_XX XX 来命名
> 2)final修饰的属性在定义时,必须赋初值,并且以后不能再修改,赋值可以在如 下位置之一【选择一个位置赋初值即可】：
 ①定义时：如public final double TAX_RATE=0.08；
 ②在构造器中
 ③在代码块中。
 3)如果final修饰的属性是静态的，则初始化的位置只能是
> 		①定义时
> ②在静态代码块不能在构造器中赋值。
>  4)final类不能继承，但是可以实例化对象。
> 5)如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可 以被继承。
class AA{
}*/
class AA{
    /*
     ①定义时：如public final double TAX_RATE=0.08；②在构造器中
    ③在代码块中。
     */
    public final double TAX_RATE=0.08;
    public final double TAX_RATE2;
    public final double TAX_RATE3;
    //2.在构造器中赋值
    public AA(double TAX_RATE2) {
        this.TAX_RATE2 = TAX_RATE2;
    }
    //在代码快复制
    {
        TAX_RATE3 = 1.88;
    }
}
class BB{
    /*
    3)如果final修饰的属性是静态的，则初始化的位置只能是①定义时
> ②在静态代码块不能在构造器中赋值。
     */
    public static final double TAX_RATE=0.08;
    public static final double TAX_RATE2;
    //public static final double TAX_RATE3;
    static {
        TAX_RATE2=0.66;
    }
    //构造器赋值不允许
//    public BB() {
//        TAX_RATE3=2.3;
//    }ERROR
}
//>  4)final类不能继承，但是可以实例化对象。
final class CC{ }
// 5)如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可 以被继承。
class EE{
    final public void laugh(){
        System.out.println("大非在笑");
    }
}
class FF extends EE{ }//遵守继承；

package com.demo.final_;
public class final_detials02 {
    public static void main(String[] args) {
        System.out.println(BBB.n1);
       // 8)包装类(Integer,Double,Float, Boolean等都是final,String也是final类。
        //不能被继承
    }
}
final class AAA{
    /*
    >5)一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法。
>6) final不能修饰构造方法(即构造器)
>7) final 和 static 往往搭配使用，效率更高，底层编译器做了优化处理,
8)包装类(Integer,Double,Float, Boolean等都是final,String也是final类。
     */
    //>5)一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法。
    //public final void cry02(){}//无意义
    public void cry02(){}
}
//   }>7) final 和 static 往往搭配使用，效率更高，底层编译器做了优化处理,
class BBB{
    //不会导致类的加载
    public final static int n1=999;
    static {
        System.out.println("BBB静态代码块被执行");
    }
}