一：基本介绍

final可以修饰__类，属性，方法和局部变量
以下需求可以用到final：

  1. 当不希望类被继承时，可以用final修饰 ```java final class PersonS{

} class Student extends PersonS{ //会报错 } 

  2. 2. **_当不希望父类的某个方法被子类覆盖/重写（override）时，可以用ffinal关键字修饰_**
  3. ```java
  4. class PersonS{
  5.     public final void say(){
  7.     }
  8. }
  9. class Student extends PersonS{
  10.     @Override
  11.     public void say() { //会报错
  12.         super.say();
  13.     }
  14. }

  1. 当不希望类的的某个属性的值被修改,可以用final修饰. ```java class PersonS{

    public final int age =18;

} class Student extends PersonS{ public Student() { super.age = 20; } }

  2. 4. **_当不希望某个局部变量被修改，可以便用final修饰_**
  3. ```java
  4. class PersonS{
  5.     public void speak(){
  6.         final int num = 19;
  7.         num = 20;
  8.     }
  9. }

二：final注意事项和细节讨论

  • final修饰的属性又叫常量，一般用XX_XX_XX来命名

    1. class Person{
    2.   public final int NUM = 100;
    3. }

  • final修饰的属性在定义时,必须赋初值,并且以后不能再修改，赋值可以在如下位置之一【选择一个位置赋初值即可】:

    • ①定义时 : 如public final double TAX_RATE=0.08;
    • ②在构造器中

    • ③在代码块中

      1. class PersonS{
      3. public final int NUM ;
      5. //构造器中赋值
      6. public PersonS() {
      7.    NUM = 10;
      8. }
      9. //代码块中
      10. {
      11.    NUM = 10;
      12. }
      13. }

  • 如果final修饰的属性是静态的，则初始化的位置只能是

    • ①定义时
    • ②在静态代码块不能在构造器中赋值。
    • 静态在类记载的时候就执行，而构造器是在创建对象的时才执行的。

    • 类加载完之后才有可能去执行构造器，如过没有创建对象的话都不执行

      1. class PersonS{
      2. public static final int NUM ;
      4. static {
      5.    NUM = 10;
      6. }
      7. }

  • final类不能继承，但是可以实例化对象。 ```java public class Finaltest { public static void main(String[] args) {

    1.   PersonS personS = new PersonS();

    } } final class PersonS{

}

  2. - **_如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承。_**
  3. ```java
  4. public static void main(String[] args) {
  5.     Student student = new Student();
  6.     student.speak();
  7. }
  8. class PersonS{
  9.     public final void speak(){
  10.         System.out.println("speak()");
  11.     }    
  12. }
  13. class Student extends PersonS{
  15. }

  • 一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法。

    1. //使用Final类无非就是不想被继承，都继承表了方法自然也无法重写
    2. final class PersonS{
    3.   public  void speak(){
    4.       System.out.println("speak()");
    5.   }
    6. }

  • final不能修饰构造方法(即构造器)

  • final和 static往往搭配使用，效率更高，不会导致类加载.底层编译器做了优化处理。

    1. public class Finaltest {
    2.   public static void main(String[] args) {
    3.       System.out.println(PersonS.NUM);
    5.   }
    6. }
    7. class PersonS{
    9.   //不加final，主方法中使用会导致累的加载，从而执行static语句
    10.   public  final static  int NUM = 100;
    11.   //加了之后不会导致累的加载，从而之访问final属性
    12.   static {
    13.       System.out.println("Person中的静态代码块");
    14.   }
    15. }

  • 包装类(Integer,Double,Float，Boolean等都是final),String也是final类。

    三：final应用举例

    1：计算面积

    image.png ```java public class Finaltest { public static void main(String[] args) {

    1.   Circle circle = new Circle(5);
    2.   Circle circle1 = new Circle(1);
    4.   System.out.println(circle1.Squera());

    } } class Circle{

    private double r;

    private final double PI;

    public Circle(double r) {

    1.    this.r = r;

    } {

    1.    PI = 3.14;

    } public double Squera() {

    1.    return PI * r * r;

    } public double getR() {

    1.    return r;

    } public void setR(double r) {

    1.    this.r = r;

    } }

  1. <a name="whb0l"></a>
  2. #### 2：细节题
  3. ```java
  4. public class Test{
  5.     public int addone(fina int x){
  6.         ++x;   //final x的值不能修改
  7.         return x+1; //没有改变x的值
  8.     }
  9. }