Final关键字

Final关键字

final中文意思是：最后的，最终的

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

在某种情况下，程序员可能有以下需求，就会使用到final关键字

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

2. 当不希望父类的某个方法被子类覆盖（重写override）时，可以用final关键字修饰

   【语法：访问修饰符 final 返回类型 方法名】

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

   【语法：public final double TAX_RATE = 0.08】

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

   【语法：final double TAX_RATE = 0.168】

final使用注意事项和细节说明

1. final修饰的属性又叫常量，用大写字母和下划线命名
2. final修饰的属性在定义时，必须赋初值，并且以后不能再修改值，赋值可以在如下位置的其中一个
   • 定义时：public final double PI = 3.141592
   • 在构造器
   • 在代码块
3. 如果final修饰的属性是静态的，则初始化的位置只能是在【（1）定义时（2）在静态代码块，不能在构造器中赋值】
4. final类不能继承，但是可以实例化对象（就是可以创建对象）
5. 如果类不是final类，但是含有的final修饰的方法，则该方法虽然不能重写，但是可以被继承
6. 一般来说，如果一个类已经是final类了，就没有必须要将方法修饰成final方法
7. final不能修饰构造器（构造器是不能被继承的）
8. final和static往往搭配使用修饰常量，效率更高 ，底层编译做优化处理，可以不用加载类信息，可以直接使用
9. 包装类【Integer Double Flaot Boolean String】都是用final修饰的

注意是：方法内不能使用访问修饰符和static

package JAVA面向对象高级部分.static_.final_;

public class Final01 {
    public static void main(String[] args) {

    }
}

//当某个类不需要被继承时，可以用final修饰
final class A {}
//final class A01 extends A {} 报错：Cannot inherit from final 'JAVA面向对象高级部分.static_.final_.A'
//因为A类是最终类用final修饰的

//当不希望父类的某个方法不被子类覆盖（重写）override时，可以用final关键字修饰
class B {
    public final void show(){
        System.out.println("我是中国人！！！");
    }
}

class B01 extends B {
    //报错：show()' cannot override 'show()' in 'JAVA面向对象高级部分.static_.final_.B'; overridden method is final
    //不能重写用final修饰的方法
//    public void show(){
//        System.out.println("我是海康人！！！");
//    }
}

//不希望类的某个属性的值被修改时，可用使用final修饰
class C {
    //一般final和static一起搭配使用效率更高，底层优化了，不用加载类信息，直接可以使用PI常量
    public static final double PI = 3.1415926;

    //当不希望某个局部变量被修改，可以使用final修饰
    public void print(){
        final int NUM = 168;
    }
}

package JAVA面向对象高级部分.static_.final_;

public class FinalDetail {
    public static void main(String[] args) {
        Student student = new Student();
        CatSOn s = new CatSOn();
        s.show();
    }
}

class Person {
    //1.final修饰的属性又叫常量，用大写字母和下划线
    public static final int MAX_NUM = 168;//a.定义时

    /**
     * 2.final修饰的属性在定义时，必须赋值，并且以后不能再修改值，
     * 赋值可以在如下的任意位置
     * a.定义时
     * b.在构造器
     * c.在代码块
     */
    public  final  int MIN_NUM ;

    //b.在构造器
    public Person() {
       // MIN_NUM = 888;
    }
    //c.在代码块
    {
        MIN_NUM = 999;
    }
}

class Animal {
    /**
     * 如果final修饰的属性静态的，则初始化的位置只能在
     * a.定义时
     * b.静态代码块中
     */
    public static final double MAX_NUM = 16.168;//a.定义时

    public static final double MIN_NUM ;
    //b.静态代码块中
    static {
        MIN_NUM = 9.999;
    }
}

//final类不能被继承，但是可以被实例化对象
class Student{}

//如果类不是final类，但是含有final修饰的方法，则方法虽然不能重写，但是可以被继承
class Cat {
    public final void show(){
        System.out.println("我是一只猫！！！");
    }
}
class CatSOn extends Cat {}

package JAVA面向对象高级部分.static_.final_;

public class FinalDetail02 {
    public static void main(String[] args) {
        System.out.println(SOn.PI);//返回值是：3.1415926
        //没有输出：我是son类的静态代码块！！！
        //说明了没有加载类信息也可以直接使用该常量，前提是要用final和static修饰
    }
}

final class Father {
    //show方法就没有必要加入final关键字了
    public final void show(){}
}

//``final``和``static``往往搭配使用修饰常量，效率更高 ，底层编译做优化处理，可以不用加载类信息，可以直接使用
class SOn {
    public static final double PI = 3.1415926;

    static {
        System.out.println("我是son类的静态代码块！！！");
    }
}

练习：

编写一个程序，能够计算圆形的面积，要求圆周率是3.1415926，赋值的位置3个方式

package JAVA面向对象高级部分.static_.final_;

public class FinalExercise01 {
    public static void main(String[] args) {
        Circle circle = new Circle(3, 3.1415962);
        System.out.println(circle.Area());
    }
}

class Circle {
    //方式一：定义时赋值
//    private final  double PI = 3.14159;
    private double radius;

    //方式二：代码块中
//    private final  double PI;
//    {
//        PI = 3.1415926;
//    }

    //方式三：构造器
    private final double PI  ;
    public Circle(double radius ,double PI) {
        this.radius = radius;
        this.PI = PI;
    }

    public double Area (){
        return radius * radius * PI;
    }
}

练习2：下面的代码是否有误，并指出

public class Something{
	public int addONe(final int x){
		++x;//错误，原因是不能修改final X的值
		return x+1'//这里可以
	}
}