【IT领域新生必看】解锁 `final` 关键字的秘密：Java 编程中的终极武器

Easonmax2024-07-11 14:38

文章目录

        • 引言
        • [什么是 `final` 关键字？](#什么是 final 关键字？)
        • [一、 `final` 变量](#一、 final 变量)
          • [`final` 局部变量](#final 局部变量)
          • [`final` 实例变量](#final 实例变量)
          • [`final` 静态变量](#final 静态变量)
        • [二、 `final` 方法](#二、 final 方法)
        • [三、 `final` 类](#三、 final 类)
        • [四、 `final` 关键字的实际应用](#四、 final 关键字的实际应用)
          • [1. 定义常量](#1. 定义常量)
          • [2. 防止方法被重写](#2. 防止方法被重写)
          • [3. 创建不可变类](#3. 创建不可变类)
          • [4. 优化性能](#4. 优化性能)
        • [五、 `final` 的一些常见误区](#五、 final 的一些常见误区)
          • [1. `final` 变量不能在构造方法中赋值](#1. final 变量不能在构造方法中赋值)
          • [2. `final` 类中的所有方法都是 `final` 的](#2. final 类中的所有方法都是 final 的)
          • [3. `final` 变量的引用不能改变](#3. final 变量的引用不能改变)
        • 结论
引言

在编程的世界里，关键字是语言设计者赋予开发者的强大工具，每个关键字都有其独特的用途和重要性。对于Java程序员来说，final 是一个极其重要且常用的关键字。它不仅有助于提高代码的安全性和稳定性，还能优化性能，帮助开发者编写更高效的代码。但是，final 关键字的用途和使用场景可能让初学者感到困惑。今天，我们将深入探讨Java中的 final 关键字，揭示它的真正威力，并展示如何在实际编程中巧妙地运用它。

什么是 final 关键字？

在Java中，final 是一个特殊的关键字，它可以用于变量、方法和类，表示它们不能被修改。具体来说：

  • final 变量：表示常量，一旦赋值就不能更改。
  • final 方法：表示该方法不能被子类重写。
  • final 类：表示该类不能被继承。
一、 final 变量

当 final 关键字用于变量时，它表示这个变量一旦被赋值，就不能再改变。这种变量通常被称为常量。

final 局部变量

局部变量是在方法、构造方法或块中声明的变量。当局部变量被声明为 final 时，它在赋值后就不能再被修改。

java 复制代码 
public class FinalExample {
    public void demonstrateFinalLocalVariable() {
        final int CONSTANT_VALUE = 10;
        System.out.println("Constant Value: " + CONSTANT_VALUE);

        // 下面的代码将会报错，因为 CONSTANT_VALUE 是 final 的，不能再被修改
        // CONSTANT_VALUE = 20;
    }

    public static void main(String[] args) {
        FinalExample example = new FinalExample();
        example.demonstrateFinalLocalVariable();
    }
}

在这个例子中，CONSTANT_VALUE 是一个 final 变量，赋值为10后不能再被修改。如果尝试重新赋值，编译器会报错。

final 实例变量

实例变量是属于对象的变量。当实例变量被声明为 final 时，它必须在对象初始化时赋值（即在构造方法中赋值），并且一旦赋值就不能再改变。

java 复制代码 
public class FinalExample {
    private final int id;

    public FinalExample(int id) {
        this.id = id;
    }

    public void showId() {
        System.out.println("ID: " + id);
    }

    public static void main(String[] args) {
        FinalExample example = new FinalExample(1);
        example.showId();

        // 下面的代码将会报错，因为 id 是 final 的，不能再被修改
        // example.id = 2;
    }
}

在这个例子中，id 是一个 final 实例变量，必须在构造方法中赋值，并且赋值后不能再被修改。

final 静态变量

静态变量是属于类的变量，当静态变量被声明为 final 时，它成为一个常量，必须在声明时或在静态初始化块中赋值，并且赋值后不能再改变。

java 复制代码 
public class FinalExample {
    public static final int MAX_VALUE = 100;

    public static void main(String[] args) {
        System.out.println("Max Value: " + MAX_VALUE);

        // 下面的代码将会报错，因为 MAX_VALUE 是 final 的，不能再被修改
        // MAX_VALUE = 200;
    }
}

在这个例子中，MAX_VALUE 是一个 final 静态变量，它在声明时被赋值为100，并且不能再被修改。

二、 final 方法

当 final 关键字用于方法时，表示该方法不能被子类重写。这对于设计不可变类或防止子类改变关键行为非常有用。

java 复制代码 
public class FinalExample {
    public final void showMessage() {
        System.out.println("This is a final method");
    }
}

class SubClass extends FinalExample {
    // 下面的代码将会报错，因为 showMessage 是 final 的，不能被重写
    // @Override
    // public void showMessage() {
    //     System.out.println("Attempting to override final method");
    // }
}

public class Main {
    public static void main(String[] args) {
        SubClass subClass = new SubClass();
        subClass.showMessage();
    }
}

在这个例子中，showMessage 方法被声明为 final，因此它不能被 SubClass 重写。如果尝试重写，编译器会报错。

三、 final 类

当 final 关键字用于类时，表示该类不能被继承。这对于设计不可变类或确保类的完整性非常有用。

java 复制代码 
public final class FinalExample {
    public void showMessage() {
        System.out.println("This is a final class");
    }
}

// 下面的代码将会报错，因为 FinalExample 是 final 的，不能被继承
// class SubClass extends FinalExample {
// }

public class Main {
    public static void main(String[] args) {
        FinalExample example = new FinalExample();
        example.showMessage();
    }
}

在这个例子中，FinalExample 类被声明为 final，因此它不能被继承。如果尝试继承，编译器会报错。

四、 final 关键字的实际应用

final 关键字在实际编程中有广泛的应用，以下是一些常见的使用场景：

1. 定义常量

在程序中定义常量时，通常使用 final 关键字。这可以确保常量的值在整个程序中保持不变。

java 复制代码 
public class Constants {
    public static final String APP_NAME = "My Application";
    public static final int MAX_USERS = 100;

    public static void main(String[] args) {
        System.out.println("App Name: " + APP_NAME);
        System.out.println("Max Users: " + MAX_USERS);
    }
}
2. 防止方法被重写

在设计类时，某些方法可能不希望被子类重写，以确保其行为的一致性和完整性。此时可以将方法声明为 final。

java 复制代码 
public class BaseClass {
    public final void logAction(String action) {
        System.out.println("Action: " + action);
    }
}

class SubClass extends BaseClass {
    // logAction 方法不能被重写
}

public class Main {
    public static void main(String[] args) {
        SubClass subClass = new SubClass();
        subClass.logAction("Login");
    }
}
3. 创建不可变类

不可变类是指一旦创建就不能修改的类。通过将类声明为 final 并将其所有成员变量声明为 final，可以实现不可变类。

java 复制代码 
public final class ImmutablePerson {
    private final String name;
    private final int age;

    public ImmutablePerson(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

public class Main {
    public static void main(String[] args) {
        ImmutablePerson person = new ImmutablePerson("Alice", 30);
        System.out.println("Name: " + person.getName());
        System.out.println("Age: " + person.getAge());

        // 下面的代码将会报错，因为 ImmutablePerson 是不可变的
        // person.name = "Bob";
        // person.age = 25;
    }
}
4. 优化性能

在某些情况下，将方法或类声明为 final 可以帮助Java编译器进行优化，提高性能。这是因为编译器可以确定这些方法或类不会被重写，从而进行内联优化。

五、 final 的一些常见误区

在使用 final 关键字时，初学者可能会遇到一些常见的误区。了解这些误区可以帮助你更好地使用 final 关键字。

1. final 变量不能在构造方法中赋值

这是一个常见的误解。实际上，final 实例变量可以在声明时赋值，也可以在构造方法中赋值。

java 复制代码 
public class FinalExample {
    private final int value;

    public FinalExample(int value) {
        this.value = value;
    }
}
2. final 类中的所有方法都是 final 的

虽然 final 类不能被继承，但这并不意味着其所有方法都是 final 的。方法是否为 final 需要显式声明。

java 复制代码 
public final class FinalClass {
    public void method1() {
        System.out.println("Method1");
    }

    public final void method2() {
        System.out.println("Method2");
    }
}

在这个例子中，`

method1不是final的，而method2是final` 的。

3. final 变量的引用不能改变

对于引用类型的 final 变量，final 关键字只保证引用本身不能改变，但引用的对象内容可以改变。

java 复制代码 
public class FinalExample {
    private final StringBuilder builder = new StringBuilder();

    public void appendText(String text) {
        builder.append(text);
    }

    public String getText() {
        return builder.toString();
    }

    public static void main(String[] args) {
        FinalExample example = new FinalExample();
        example.appendText("Hello, ");
        example.appendText("World!");

        System.out.println(example.getText());

        // 下面的代码将会报错，因为 builder 是 final 的，不能再赋值
        // example.builder = new StringBuilder();
    }
}

在这个例子中，builder 是一个 final 引用，虽然引用不能改变，但 StringBuilder 对象的内容可以改变。

结论

final 关键字是Java编程中一个非常重要的工具，它有助于提高代码的安全性、稳定性和性能。通过理解和正确使用 final 关键字，我们可以编写出更健壮、更高效的代码。

无论是定义常量、防止方法被重写、创建不可变类，还是优化性能，final 关键字都扮演着重要的角色。希望通过这篇文章，你能更深入地理解 final 关键字的使用场景和实际应用，让你的编程技能更上一层楼。

继续探索和实践 final 关键字的各种用法吧，你会发现它在编程中是一个不可或缺的终极武器！

相关推荐
love530love11 分钟前
【笔记】旧版MSYS2 环境中 Rust 升级问题及解决过程
开发语言·人工智能·windows·笔记·python·rust·virtualenv
clk660730 分钟前
Spring Boot
java·spring boot·后端
扣丁梦想家34 分钟前
✅ 常用 Java HTTP 客户端汇总及使用示例
java·开发语言·http
Code_流苏36 分钟前
C++课设：智能优惠快餐点餐系统
开发语言·c++·课设·期末大作业·快餐点餐系统·智能优惠算法
sss191s1 小时前
Java 集合面试题 PDF 及常见考点解析与备考指南
java·开发语言·pdf
七七&5561 小时前
java面试-场景题
java·python·面试
老刘忙Giser1 小时前
c# List＜string＞.Add(s) 报错：UnsupportedOperationException
开发语言·c#
loser.loser1 小时前
QQ邮箱发送验证码(Springboot)
java·spring boot·mybatis
itwlz1 小时前
vite配置@别名，以及如何让IDE智能提示路经
开发语言·前端·javascript
lichenyang4531 小时前
添加按钮跳转页面并且根据网站的用户状态判断是否显示按钮
开发语言·前端·javascript
热门推荐
01基于STM32的智能电池管理系统02KGG转MP3工具|非KGM文件|解密音频03YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】04海康Visionmaster-常见问题排查方法-启动阶段05从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑06【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！07VMware虚拟机安装Win7专业版保姆级教程（附镜像包）08DeepSeek各版本说明与优缺点分析09组基轨迹建模 GBTM的介绍与实现（Stata 或 R）10神经网络架构KAN确实具有一些独特的特点及底层原理和应用场景