final 是 Java 中一个重要的修饰符，可用于修饰类、方法和变量，其核心作用是限制被修饰对象的可变性。以下是其具体用法及细节说明：

一、修饰类（Class）

当 final 修饰类时，该类不能被继承。

  • 应用场景：

    • 用于设计不需要被继承的工具类（如 Java 中的 String 类）。
    • 防止类的功能被修改或扩展，保证代码的稳定性。

  • 示例：

    final class UtilityClass {
  // 工具类方法，不能被继承
  public static void helperMethod() {
      // ...
  }
}
  • 注意：类中方法和变量仍可根据需求使用 final 修饰。

二、修饰方法（Method）

当 final 修饰方法时，该方法不能被重写（Override）。

  • 应用场景：

    • 保护父类的核心方法不被子类修改（如 Object 类的 getClass() 方法）。
    • 优化性能：JVM 可对 final 方法进行内联（Inline）优化。

  • 示例：

    class Parent {
  final void coreMethod() {
      // 核心逻辑，不允许子类重写
  }
}

  • 注意：

    • final 方法仍可被继承和调用，但子类无法覆盖其实现。
    • 若一个类被声明为 final，则其所有方法自动成为 final 方法。

三、修饰变量（Variable）

当 final 修饰变量时，该变量成为常量，值一旦初始化就不能被修改。根据变量类型，用法分为以下三类：

1. 成员变量（Member Variable）

  • 规则：

    • 必须在声明时或构造函数中初始化。
    • 若为静态变量（static final），需在声明时或静态代码块中初始化。

  • 示例：

    class Constants {
  // 实例常量（每个对象可不同）
  final int INSTANCE_CONSTANT = 10;
  
  // 类常量（所有对象共享）
  static final String CLASS_CONSTANT = "HELLO";
  
  // 延迟初始化实例常量
  final double PI;
  {
      PI = 3.14159; // 在代码块中初始化
  }
  
  // 静态常量延迟初始化
  static final double E;
  static {
      E = 2.71828; // 在静态代码块中初始化
  }
}
2. 局部变量（Local Variable）

  • 规则：

    • 必须在声明时初始化，且之后不能重新赋值。
    • 可用于修饰方法内的临时变量或形参。

  • 示例：

    void method() {
  final int localVar = 20; // 局部常量
  localVar = 30; // 编译错误：无法修改final变量
  
  // 修饰形参（JDK 8+ 隐式支持，可省略final）
  void process(final String name) {
      // name 不能被重新赋值
  }
}
3. 引用类型变量

  • 规则：

    • final 修饰引用时，引用地址不能改变，但引用对象的内容可以修改。

  • 示例：

    final StringBuilder sb = new StringBuilder("Hello");
sb.append(" World"); // 允许修改对象内容
sb = new StringBuilder("Hi"); // 编译错误：不能修改引用地址

四、final 与其他关键字的组合使用

  1. static final：

    • 用于定义类级别的常量（如 Math.PI），内存中仅存一份。
    • 必须在声明时或静态代码块中初始化。

  2. private final：

    • 修饰私有成员变量，确保其值不可变且无法被外部访问或修改。
    • 常用于实现不可变类（如 String）。

五、final 的设计思想与最佳实践

  1. 不可变性（Immutability）：

    • 通过 final 修饰成员变量，配合私有构造器，实现不可变类（如 Integer、BigDecimal）。

  2. 线程安全：

    • final 变量在多线程环境中无需额外同步，因为其值不可变。

  3. 防御性编程：

    • 对不希望被修改的关键数据或方法添加 final，避免意外修改。

六、常见面试问题

  1. final、finally 和 finalize() 的区别？

    • final 是修饰符；finally 是异常处理块；finalize() 是对象回收前的回调方法。

  2. String 类为什么是 final？

    • 保证哈希值不变（字符串常用作哈希键），提升安全性（防止被继承后重写方法）。

通过合理使用 final 修饰符，可增强代码的健壮性、安全性和可维护性，同时帮助 JVM 进行优化。在 Java 里，final 修饰符能够对类、方法和变量进行修饰，从而让它们具备不可变的特性。下面为你详细介绍其具体用法：

1. 修饰类

当 final 用于修饰类时，意味着这个类不能被其他类继承，也就是该类无法派生出子类。

public final class FinalClass {
    // 类的具体内容
}

// 以下代码会引发编译错误，因为 FinalClass 不能被继承
// class SubClass extends FinalClass {}

典型应用场景：像 String、Integer 等不可变类以及工具类，通常会使用 final 修饰，防止被恶意继承和篡改。

2. 修饰方法

final 修饰方法时，表示该方法不能被重写。

public class Parent {
    public final void display() {
        System.out.println("父类中的 final 方法");
    }
}

public class Child extends Parent {
    // 下面的代码会出现编译错误，因为无法重写 final 方法
    // @Override
    // public void display() { ... }
}

设计意图：主要是为了确保方法的实现逻辑不被改变，保障核心功能的安全性。

3. 修饰变量

final 修饰变量时，表明该变量一旦被赋值，其值就不能再被更改，相当于常量。

public class FinalVariableExample {
    // 静态常量
    public static final double PI = 3.14159;
    
    // 实例常量，必须在声明时或者构造方法中进行初始化
    public final int MAX_SIZE;
    
    public FinalVariableExample() {
        MAX_SIZE = 100;
    }
    
    public void method() {
        // 局部常量
        final int localVar = 50;
        // localVar = 60;  // 编译错误：无法对 final 变量进行赋值
    }
}

特别说明：

  • 引用类型：当 final 修饰引用类型变量时，变量不能再指向其他对象，但对象自身的内容是可以修改的。

    final List<String> list = new ArrayList<>();
list.add("元素");  // 允许操作
// list = new ArrayList<>();  // 编译错误
  • 空白 final：被 final 修饰但未在声明时赋值的变量，需要在构造方法中完成初始化。

4. 修饰参数

在方法参数前加上 final 修饰符，意味着在方法内部不能对该参数进行重新赋值。

public void calculate(final int x) {
    // x = 10;  // 编译错误：不能修改 final 参数
}

主要作用：可以防止方法内部意外修改参数值，增强代码的健壮性。

核心作用

  • 安全性：避免子类对类、方法或者变量进行修改，降低代码出错的风险。
  • 性能优化：有助于 JVM 对代码进行优化，例如对 final 方法进行内联调用。

使用建议

  • 要避免过度使用 final，以免影响代码的灵活性。
  • 对于不可变对象，要始终使用 final 进行修饰。
  • 在设计 API 时，如果某些方法不希望被重写，就应该将其声明为 final。
最后修改：2025 年 06 月 26 日
© 允许规范转载
如果觉得我的文章对你有用，请随意赞赏