final关键字在java中有三种主要用法。1. 修饰变量：变量一旦被赋值不可更改，final成员变量需在声明或构造器中初始化，final局部变量只能赋值一次；2. 修饰方法：该方法不能被子类重写，用于保护关键逻辑并可能提升性能；3. 修饰类：该类不能被继承，用于构建不可变类或防止设计破坏。此外，final可提高线程安全性和代码可靠性，但final不等于完全不可变，要实现immutable对象还需满足类不可继承、成员变量不可修改等条件。
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(); }
final影响性能吗？
理论上，final方法可以允许编译器进行内联优化，从而提高性能。但在实际应用中，这种优化效果并不总是明显的。现代JVM已经非常智能，即使没有final关键字，也可以对一些方法进行内联优化。
过度的使用final关键字可能会使代码变得难以维护，因此需要在性能和可维护性之间进行权衡。通常情况下，只有在性能瓶颈的代码中才需要考虑使用final关键字进行优化。
总而言之，理解final关键字的各种用法及其背后的设计思想，对于编写高质量的Java代码至关重要。正确地使用final关键字可以提高代码的可靠性、安全性、可维护性和性能。
