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静态代码块");
}
}
