Final

final

基本介绍：

final可以修饰类、属性、方法和局部变量

下面情况下可能会用到final

• 当不希望类被继承时，可以用final修饰；
• 当不希望父类的某个方法被子类覆盖/重写时，可以用final修饰；
• 当不希望类的某个属性的值被修改，可以用final修饰；
• 当不希望某个局部变量被修改，可以用final；

案例：

package com.example.final_;



/**
 * @author gaoqinghui
 * @date 2022/4/27 16:43
 * final关键字的基本介绍
 */
public class Final01 {
    public static void main(String[] args) {

    }
}

//1.当不希望类被继承时，可以用final修饰；
final class A { }

//class B extends A { }


//2.当不希望父类的某个方法被子类覆盖/重写时，可以用final修饰；

class AA {
    public final void hi(){};
}

//class BB extends AA{
//    @Override
//    public void hi() {
//        super.hi();
//    }
//}


//3.当不希望类的某个属性的值被修改，可以用final修饰；

class AAA {
    public final double n1 = 100.1;

}

//4.当不希望某个局部变量被修改，可以用final；

class AAAA {
    public void say(){
        final double n1 = 100;
        //n1 = 200;
    }
}

final细节

• final修饰的属性又叫常量，一般用XX_XX_XX来命名；
• final修饰的属性在定义时，必须赋初值，并且以后不能再修改，赋值可以在位置之一(选择一个位置赋初值即可)：
  • 定义时，如public final double TAX_RATE =0.08;
  • 在构造器中
  • 在代码块中
• 如果final修饰的属性时静态的，则初始化的位置只能是在：
  • 定义时
  • 在静态代码块中
  • ！不能在构造器中赋值，因为静态代码块和静态属性在类加载时就被运行，构造器最后才被执行；
• final类不能继承，但是可以实例化对象；
• 如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是类可以被继承；
• 一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法。
  • 因为将方法用final修饰是为了不让别人重写这个方法，但是如果不能继承的话重写的类就无从谈起；
• final不能修饰构造方法(构造器)
• final和static往往搭配使用，效率更高，因为底层编译器做了优化处理，两者搭配使用不会导致类加载，
  • 因为往往我们调用静态属性会导致类加载，如果静态代码块中有内容就会被输出，而我们只是想调用一下那个静态变量而已。
• 包装类(Integer,Double,Float,Boolean等都是final修饰)，String也是final类。

package com.example.final_;

/**
 * @author gaoqinghui
 * @date 2022/4/27 17:09
 */
public class FinalDeatil01 {
    public static void main(String[] args) {
        new A3();
        new A5().say();
        System.out.println(A6.n4);
    }
}

class A1 {//final修饰的是普通属性，有下面三种定义
    private final double n1 = 100;  //1.在定义时赋初值
    private final double n2;
    private final double n3;
    { //2.在代码块中赋初值
        n2 = 200;
    }

    public A1() {  //在构造器中赋初值
        n3 = 300;
    }

}

class A2 {//final修饰的是静态属性，有下面两种定义
    private static final int n4 = 400;  //在定义时
    private static final int n5;


    static {    //在静态代码块中
        n5 = 500;
    }

}

//final类不能继承，但是可以实例化对象；

final  class A3 { }

//如果类不是final类，
//但是含有final方法，则该方法虽然不能重写，但是可以被继承；

class A4 {
    public final void say(){
        System.out.println("hello");
    }
}

class A5 extends A4 { }

//final和static往往搭配使用，效率更高，
// 因为底层编译器做了优化处理，两者搭配使用**不会导致类加载**
class A6 {
    public static final double n4 = 100;
    static {
        System.out.println("静态代码块被执行");
    }
}