Javafinal关键字怎么用？搞懂这三个经典场景举一反三

在Java中，`final`关键字扮演着关键角色，用于声明“最终”或“不可改变”的状态。本文深入探讨了`final`的三种主要用法，并通过实例解析其在实际开发中的应用。首先，`final`可修饰变量，保证其赋值后不可更改，成员变量需在声明或构造器中初始化，局部变量仅能赋值一次。其次，`final`修饰方法可防止子类重写，保护关键逻辑并潜在提升性能。最后，`final`修饰类则禁止继承，常用于构建不可变类或防止设计被破坏。此外，文章还阐述了`final`如何提高线程安全性和代码可靠性，并区分了`final`与`immutable`的概念，强调实现完全不可变对象的条件。掌握`final`的正确使用，对于编写健壮、高效的Java代码至关重要。

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

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

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

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

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

• 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，需要满足以下条件：

1. 类本身是final的，防止被继承。
2. 所有的成员变量都是final的。
3. 所有的成员变量都是immutable的，或者如果成员变量是可变的，则不能直接访问，必须通过防御性拷贝来保护。
4. 没有提供修改对象状态的方法（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关键字可以提高代码的可靠性、安全性、可维护性和性能。

以上就是《Javafinal关键字怎么用？搞懂这三个经典场景举一反三》的详细内容，更多关于线程安全,不可变性,方法重写,final关键字,immutable对象的资料请关注golang学习网公众号！