深入剖析 Java 中的 static 与 final

简介

在 Java 编程中，static 和 final 是两个非常重要且常用的关键字。它们各自有着独特的作用和用途，并且在很多情况下容易混淆。深入理解这两个关键字的概念、使用方法以及最佳实践，对于编写高质量、可维护的 Java 代码至关重要。本文将详细探讨 static 和 final 在 Java 中的相关知识，帮助读者更好地掌握它们的用法。

static 基础概念
final 基础概念
static 使用方法
- 静态变量
- 静态方法
- 静态代码块
final 使用方法
- 最终变量
- 最终方法
- 最终类
常见实践
- static 常见实践
- final 常见实践
最佳实践
- static 最佳实践
- final 最佳实践
小结
参考资料

1. static 基础概念

static 关键字在 Java 中用于修饰成员（变量和方法），表示这些成员属于类本身，而不是属于类的某个实例。也就是说，无论创建多少个类的实例，静态成员都只有一份，被所有实例共享。

2. final 基础概念

final 关键字在 Java 中有三种主要用途：修饰变量、方法和类。当 final 修饰变量时，表示该变量一旦被赋值就不能再改变；修饰方法时，表示该方法不能被重写；修饰类时，表示该类不能被继承。

3. static 使用方法

静态变量

静态变量是属于类的变量，而不是属于类的实例。通过类名直接访问静态变量，无需创建类的实例。

public class StaticExample {
    // 静态变量
    public static int staticVariable = 10;

    public static void main(String[] args) {
        // 通过类名访问静态变量
        System.out.println(StaticExample.staticVariable); 
    }
}

静态方法

静态方法同样属于类，可通过类名直接调用，不需要创建类的实例。静态方法不能访问非静态成员（变量和方法），因为非静态成员依赖于类的实例，而静态方法在类加载时就已经存在，此时可能还没有创建任何实例。

public class StaticMethodExample {
    // 静态方法
    public static void staticMethod() {
        System.out.println("这是一个静态方法");
    }

    public static void main(String[] args) {
        // 通过类名调用静态方法
        StaticMethodExample.staticMethod(); 
    }
}

静态代码块

静态代码块在类加载时执行，并且只执行一次。常用于初始化静态变量。

public class StaticBlockExample {
    // 静态变量
    public static int staticVar;

    // 静态代码块
    static {
        staticVar = 20;
        System.out.println("静态代码块执行，初始化 staticVar 为 " + staticVar);
    }

    public static void main(String[] args) {
        System.out.println("在 main 方法中访问 staticVar: " + staticVar);
    }
}

4. final 使用方法

最终变量

当 final 修饰变量时，该变量一旦被赋值就不能再改变。如果是基本数据类型，其值不能改变；如果是引用类型，其引用不能再指向其他对象，但对象内部的状态可以改变。

public class FinalVariableExample {
    public static void main(String[] args) {
        // 基本数据类型的 final 变量
        final int finalInt = 10;
        // finalInt = 20;  // 编译错误，不能重新赋值

        // 引用类型的 final 变量
        final StringBuilder finalStringBuilder = new StringBuilder("Hello");
        finalStringBuilder.append(" World"); // 可以改变对象内部状态
        System.out.println(finalStringBuilder); 
    }
}

最终方法

final 修饰的方法不能被重写。常用于防止子类改变父类的核心逻辑。

class Parent {
    // 最终方法
    public final void finalMethod() {
        System.out.println("这是父类的最终方法");
    }
}

class Child extends Parent {
    // 尝试重写最终方法会导致编译错误
    // @Override
    // public void finalMethod() {
    //     System.out.println("这是子类重写的最终方法");
    // }
}

最终类

final 修饰的类不能被继承。常用于创建一些不可变的类，确保其行为和状态不会被改变。

// 最终类
final class FinalClass {
    public void printMessage() {
        System.out.println("这是最终类中的方法");
    }
}

// class SubFinalClass extends FinalClass {  // 编译错误，不能继承最终类
// }

5. 常见实践

static 常见实践

工具类：创建包含多个静态方法的工具类，例如 Math 类，其中的 sqrt、sin 等方法都是静态方法，方便在不创建实例的情况下调用。

public class MathUtils {
    public static double squareRoot(double number) {
        return Math.sqrt(number);
    }
}

public class Main {
    public static void main(String[] args) {
        double result = MathUtils.squareRoot(16);
        System.out.println(result); 
    }
}

全局变量：使用静态变量来存储全局共享的数据，例如配置信息。

final 常见实践

常量定义：使用 final 修饰变量来定义常量，例如 Math.PI 就是一个 final 常量。

public class Constants {
    public static final double PI = 3.14159;
}

public class Main {
    public static void main(String[] args) {
        double circleArea = Constants.PI * 5 * 5;
        System.out.println(circleArea); 
    }
}

不可变类：创建 final 类并将所有成员变量设为 final，确保类的不可变性，如 String 类。

6. 最佳实践

static 最佳实践

避免滥用静态成员：过多使用静态成员可能导致代码的可维护性和可测试性降低，因为静态成员的状态是全局共享的，容易产生副作用。
静态成员的访问控制：合理设置静态成员的访问修饰符，通常将工具类的静态方法和常量设为 public，而内部使用的静态变量设为 private。

final 最佳实践

尽量使用 final 修饰变量：这样可以提高代码的可读性和可维护性，同时有助于编译器进行优化。
对于不需要子类重写的方法，使用 final 修饰：防止意外的重写导致程序逻辑错误。

小结

本文详细介绍了 Java 中 static 和 final 关键字的基础概念、使用方法、常见实践以及最佳实践。static 关键字用于创建类级别的成员，被所有实例共享；final 关键字用于确保变量、方法或类的不可变性。正确使用这两个关键字可以提高代码的质量和可维护性。希望读者通过本文的学习，能够在实际编程中更加熟练、准确地运用 static 和 final。

参考资料

Oracle Java 教程
《Effective Java》（作者：Joshua Bloch）

以上就是关于 static vs final java 的详细技术博客内容，希望对读者有所帮助。