java中的final怎么理解 final关键字的3种用法看完这篇全明白-java教程-PHP中文网

java中的final怎么理解 final关键字的3种用法看完这篇全明白

裘德小鎮的故事

发布： 2025-06-29 11:45:02

原创

831人浏览过

final关键字在java中有三种主要用法。1. 修饰变量：变量一旦被赋值不可更改，final成员变量需在声明或构造器中初始化，final局部变量只能赋值一次；2. 修饰方法：该方法不能被子类重写，用于保护关键逻辑并可能提升性能；3. 修饰类：该类不能被继承，用于构建不可变类或防止设计破坏。此外，final可提高线程安全性和代码可靠性，但final不等于完全不可变，要实现immutable对象还需满足类不可继承、成员变量不可修改等条件。

java中的final怎么理解 final关键字的3种用法看完这篇全明白

final关键字在Java中扮演着一个重要的角色，它用于表示“最终的”或“不可改变的”状态。理解final对于编写健壮、高效的代码至关重要。简单来说，final可以应用于变量、方法和类，分别有不同的含义。

final关键字主要有三种用法：修饰变量（包括成员变量和局部变量）、修饰方法和修饰类。每种用法都涉及到不同的语义和限制，理解这些限制对于编写高质量的Java代码至关重要。

final修饰变量：不可变性的保证

final修饰变量时，意味着该变量一旦被赋值，其值就不能再被修改。这听起来很简单，但其中蕴含着一些微妙之处。

立即学习“Java免费学习笔记（深入）”；

final成员变量： 必须在声明时或者构造器中进行初始化。这意味着，每个对象创建时，其final成员变量都必须有确定的值。如果一个类有多个构造器，那么每个构造器都必须确保所有final成员变量都被初始化。这可以避免出现未初始化的final变量，从而保证了对象状态的完整性。
```
public class MyClass {
    private final int x; // 必须初始化

    public MyClass(int x) {
        this.x = x; // 在构造器中初始化
    }

    public int getX() {
        return x;
    }
}
```
登录后复制
值得注意的是，对于引用类型的final成员变量，final仅仅保证引用本身不可变，即不能指向另一个对象。但对象内部的状态是可以改变的。例如：
```
public class MyClass {
    private final List<String> myList;

    public MyClass(List<String> list) {
        this.myList = list; // 初始化为传入的list
    }

    public void modifyList() {
        myList.add("new element"); // 合法，因为只是修改了list的内容
    }

    public List<String> getMyList() {
        return myList;
    }

}
```
登录后复制
在这个例子中，myList是final的，但我们可以通过modifyList()方法修改列表的内容。如果需要完全的不可变性，需要使用不可变集合（如Guava的ImmutableList）或者手动创建对象的深拷贝。
final局部变量： 可以在声明后赋值，但只能赋值一次。这在lambda表达式和匿名内部类中尤其有用，因为它们只能访问final或 effectively final的局部变量。
```
public void myMethod() {
    final int y;
    y = 10; // 第一次赋值
    // y = 20; // 错误：不能再次赋值
}
```
登录后复制
"effectively final" 是指变量虽然没有被声明为final，但在初始化后没有被修改过，因此在lambda表达式或匿名内部类中可以被当作final变量使用。

final修饰方法：阻止方法重写

当final修饰一个方法时，意味着该方法不能被子类重写（override）。这通常用于防止子类修改父类的关键逻辑。

public class Parent {
    public final void myMethod() {
        System.out.println("Parent's myMethod");
    }
}

public class Child extends Parent {
    // @Override
    // public void myMethod() { // 编译错误：不能重写final方法
    //     System.out.println("Child's myMethod");
    // }
}

登录后复制

final方法可以提高代码的安全性，防止子类意外地修改父类的行为。另外，final方法在某些情况下可以提高性能，因为编译器可以对final方法进行内联优化。

final修饰类：禁止继承

当final修饰一个类时，意味着该类不能被继承。这通常用于创建不可变的类，或者防止子类破坏类的设计。

public final class ImmutableClass {
    private final int x;

    public ImmutableClass(int x) {
        this.x = x;
    }

    public int getX() {
        return x;
    }
}

// class SubClass extends ImmutableClass { // 编译错误：不能继承final类
//
// }

登录后复制

String类就是一个典型的final类。它的不可变性使得它可以安全地在多线程环境中使用，并且可以作为HashMap的键。

为什么使用final？final关键字的好处

使用final关键字有很多好处，不仅仅是为了防止修改。

不可变性： final可以保证变量、方法或类的状态不可变，这可以提高代码的可靠性和安全性。不可变对象更容易理解和调试，并且可以安全地在多线程环境中使用。
性能优化： final方法允许编译器进行内联优化，这可以提高代码的执行效率。
设计约束： final可以强制执行设计约束，防止子类修改父类的关键逻辑或破坏类的设计。
线程安全： final变量是线程安全的，因为它们的值在初始化后不会被修改。

final和immutable有什么区别？

虽然final可以用于创建不可变对象，但final本身并不等同于immutable。final只是保证变量的引用不可变，而immutable则要求对象的状态在创建后不能被修改。

一个类要成为immutable，需要满足以下条件：

类本身是final的，防止被继承。
所有的成员变量都是final的。
所有的成员变量都是immutable的，或者如果成员变量是可变的，则不能直接访问，必须通过防御性拷贝来保护。
没有提供修改对象状态的方法（setter方法）。

public final class ImmutablePerson {
    private final String name;
    private final int age;
    private final List<String> hobbies; // 必须是不可变集合或者深拷贝

    public ImmutablePerson(String name, int age, List<String> hobbies) {
        this.name = name;
        this.age = age;
        this.hobbies = new ArrayList<>(hobbies); // 防御性拷贝
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public List<String> getHobbies() {
        return new ArrayList<>(hobbies); // 返回防御性拷贝
    }
}

登录后复制

在这个例子中，ImmutablePerson类是immutable的，因为它满足了上述所有条件。

final关键字在实际项目中的应用场景

在实际项目中，final关键字被广泛使用。

配置常量： 使用final static修饰的常量，用于存储配置信息。

public class Config {
    public static final String DEFAULT_NAME = "default";
    public static final int MAX_CONNECTIONS = 100;
}

登录后复制

缓存结果： 使用final修饰的变量，用于缓存计算结果，避免重复计算。

public class CacheExample {
    private final int result;

    public CacheExample(int input) {
        this.result = calculate(input);
    }

    private int calculate(int input) {
        // 复杂的计算逻辑
        return input * 2;
    }

    public int getResult() {
        return result;
    }
}

登录后复制

构建不可变对象： 使用final修饰的类和成员变量，用于构建不可变对象，提高代码的可靠性和安全性。例如，Guava的ImmutableList、ImmutableMap等。

模板方法模式： 在模板方法模式中，父类定义算法的骨架，子类实现具体的步骤。可以使用final修饰模板方法，防止子类修改算法的骨架。

public abstract class AbstractTemplate {
    public final void templateMethod() {
        step1();
        step2();
        step3();
    }

    protected abstract void step1();
    protected abstract void step2();
    protected abstract void step3();
}

登录后复制