Java 静态成员：static 字段与静态方法

属于类，而不属于对象

到目前为止，你写的大多数字段和方法都属于对象：每次调用 new，每个实例都会得到一份自己的字段，方法也针对那个具体对象的状态运行。static 关键字把这一点反了过来。static 成员属于类本身：它只有一份，由所有实例共享，而且无论你是否创建过对象，它都存在。

这一个区别就能解释静态字段、静态方法、常量，甚至解释为什么 main 总是 static 的。

共享的 static 字段

非静态字段让每个对象都有自己的存储位置。static 字段则让类拥有一个所有人共享的位置。经典的例子是一个记录创建了多少个对象的计数器：

class User {
    static int count = 0;     // one shared slot for the whole class
    String name;              // one per object

    User(String name) {
        this.name = name;
        count++;              // bump the shared counter on every construction
    }
}

public class Main {
    public static void main(String[] args) {
        new User("Ada");
        new User("Linus");
        new User("Grace");

        System.out.println("users created: " + User.count);
    }
}

注意读取计数器时写的是 User.count，通过的是类名，因为这个值不属于任何一个 User。而每个 name 都存在于各自的对象中。通过任何一个实例修改 count，所有实例都能看到新值，因为它只有一份。

static 方法

static 方法同样属于类，所以不需要对象，直接通过类来调用：

class MathUtils {
    static int square(int x) {
        return x * x;
    }

    static int max(int a, int b) {
        return a > b ? a : b;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(MathUtils.square(7));
        System.out.println(MathUtils.max(3, 9));
    }
}

标准库背后正是这种模式：Math.max、Integer.parseInt、Arrays.sort 和 List.of 都是 static 的，它们是不需要对象就能工作的工具方法。当一项工作只依赖于参数、不依赖于任何对象自身的状态时，就用 static 方法。

最大的陷阱：static 看不到实例成员

static 方法运行时没有任何对象，所以也没有 this。这意味着它不能直接访问实例字段或调用实例方法，因为没有具体的对象可以从中读取。这是初学者使用 static 时最常犯的错误：

class Account {
    int balance = 100;          // instance field

    static int show() {
        return balance;         // COMPILE ERROR: non-static field 'balance'
    }                           // cannot be referenced from a static context
}

解决方法有两个：要么把它改成实例方法（去掉 static，这样它就有 this 了），要么显式地把对象传进去：

class Account {
    int balance = 100;

    static int show(Account a) {     // take the object as a parameter
        return a.balance;
    }
}

public class Main {
    public static void main(String[] args) {
        Account a = new Account();
        System.out.println(Account.show(a));
    }
}

反过来则没有问题：实例方法可以随意读取 static 字段、调用 static 方法，因为类级别的共享数据始终存在。

用 static final 定义常量

把 static 和 final 组合起来，就得到一个常量：一个永远不能改变的共享值。按照惯例，常量用 UPPER_SNAKE_CASE 命名：

class Circle {
    static final double PI = 3.14159265;

    double radius;

    Circle(double radius) { this.radius = radius; }

    double area() {
        return PI * radius * radius;   // instance method using a static constant
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.printf("%.2f%n", new Circle(2).area());
    }
}

static final 是表达“属于这个类型的固定值”的惯用写法，比如标准库中的 Integer.MAX_VALUE 或 Math.PI。加上 static，就不会为每个对象浪费一份副本；加上 final，就没人能给它重新赋值。

static 初始化块

简单的 static 字段可以在声明时直接初始化。当初始化需要真正的逻辑时，比如用 HashMap 构建查找表、读取配置，就使用 static 代码块。它只在类第一次加载时运行一次，早于任何对象的创建：

import java.util.HashMap;
import java.util.Map;

class Roman {
    static final Map<Character, Integer> VALUES = new HashMap<>();

    static {                       // runs once, at class load time
        VALUES.put('I', 1);
        VALUES.put('V', 5);
        VALUES.put('X', 10);
        VALUES.put('L', 50);
    }

    static int valueOf(char c) {
        return VALUES.get(c);
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(Roman.valueOf('X') + Roman.valueOf('I'));
    }
}

无论你使用这个类多少次，这个代码块都只执行一次，所以它正适合放置一次性的、整个类范围的初始化工作。

什么时候用 static

一个简单的经验法则：

• 只有对所有实例来说确实共享的数据，才用静态字段，比如计数器、缓存、常量。如果两个对象可能合理地存放不同的值，它就应该是实例字段。
• 当结果只取决于参数、不取决于任何对象的状态时（纯粹的工具函数），用静态方法。
• 默认使用实例成员。滥用 static 会悄悄把你的程序变成一堆全局状态，既难以测试，也难以理解。static 是例外，而不是起点。

下一页：枚举

一个 static final 常量适合表示一个固定值，但当你有一小组固定的相关值时，比如方向、一周中的每一天、订单状态，Java 有一种专门的类型，比零散的常量更安全、表达力也更强。那就是 enum，也是下一页的内容。