Java基础-final关键字

package com.hspedu.final_;

public class Course393 {
    public static void main(String[] args) {
        // final关键字

        /*
         * 1、final修饰类，这个类就不能被其他类继承
         * 2、final修饰方法，这个方法不能被继承的子类重写（override）
         * 3、final修饰属性，这个属性的值就无法修改
         * 4、final修饰局部变量，这个局部变量不能被修改(称为局部常量)
         * */

        E e = new E();
//        e.TAX_RATE = 0.09;

    }
}


final class A {

}

//class B extends A {
//
//}


class C {

    public final void hi() {

    }
}

class D extends C {
//    @Override
//    public void hi() {
//        System.out.println("重写C类的hi方法");
//    }
}


class E {

    public final double TAX_RATE = 0.08;
}


class F {

    public void cry() {
        final double NUM = 0.01;
//        NUM = 1;
        System.out.println("NUM = " + NUM);
    }
}

package com.hspedu.final_;

public class Course394 {
    public static void main(String[] args) {
        // final细节

        /*
         * 1、final一般命名：XX_XXX;
         * 2、final定义时，必须初始化赋值：
         *   (1)定义赋值，(2)构造器赋值，(3)代码块赋值
         * 3、如果final修饰的属性是静态static的，
         *  (1)定义赋值，(2)静态代码块，不能在构造器中赋值
         *  原因：静态成员是在类加载的时候初始化的，对象创建才会调用构造器
         * 4、final不能继承，可以实例化
         * 5、final的方法是不能重写override，但是可以继承提供给子类使用
         * */

        CC cc = new CC();
        new EE().cal();

    }
}

class AA {

    public final double TAX_RETE = 0.08;

    public final double TAX_RATE2;

    public final double TAX_RATE3;


    public AA() {
        TAX_RATE2 = 1.1;
    }

    {
        TAX_RATE3 = 8.8;
    }
}


class BB {

    public static final double TAX_RATE = 99.9;

    public static final double TAX_RATE2;

//    public static final double TAX_RATE3;


    static {
        TAX_RATE2 = 3.3;
    }

//    public BB() {
//        TAX_RATE3 = 8.8;
//    }
}


final class CC {

}


class DD {

    public final void cal() {
        System.out.println("cal");
    }
}

class EE extends DD {
//    public final void cal() {}
}

package com.hspedu.final_;

public class Course394 {
    public static void main(String[] args) {
        // final细节2

        /*
         * 1、一般对于一个final的类，没必要将内部的方法再用final修饰
         *   该类已经不能被继承了，就没有重写
         * 2、final不能修饰构造器
         * 3、final和static一般是搭配使用，不会导致类的加载，底层编译器做了优化
         * 4、包装类（Integer、String、Double...）这些都是final修饰的类，不能被继承
         * */

        // 没有调用静态代码块
        System.out.println(BBB.NUM);
    }
}

final class AAA {

    public final void cry() {
    }
}

class BBB {
    public final static int NUM = 10000;

    static {
        System.out.println("BBB静态代码块");
    }
}