`static` 关键字的用法：静态变量、静态方法与静态代码块的加载时机

好的，咱们这就开聊 static 这个磨人的小妖精！它是 Java 世界里一个非常重要的关键字，搞懂它，你就能在代码的世界里更加游刃有余。

static：一个略带神秘色彩的关键字

static，从字面意思来看，就是“静态的”、“静止的”。在 Java 的语境下，它赋予变量、方法和代码块一些特殊的性质，让它们不再那么“随心所欲”，而是与类本身紧密联系。这种联系带来了一些有趣的特性，也影响了它们的加载时机和使用方式。

1. 静态变量（Static Variables）：类的“共有财产”

静态变量，也称为类变量，用 static 关键字修饰。它们不属于类的任何一个实例，而是属于类本身。换句话说，所有类的实例共享同一个静态变量。就像一个公司的公共财产，大家都可以用，但只有一份。

声明方式：

public class MyClass {
    public static int count = 0; // 静态变量
    public int instanceVariable; // 实例变量

    public MyClass() {
        count++; // 每次创建实例，静态变量 count 加 1
        instanceVariable = count; // 实例变量赋值
    }

    public static void main(String[] args) {
        MyClass obj1 = new MyClass();
        System.out.println("obj1.instanceVariable: " + obj1.instanceVariable); // 输出 1
        System.out.println("MyClass.count: " + MyClass.count); // 输出 1

        MyClass obj2 = new MyClass();
        System.out.println("obj2.instanceVariable: " + obj2.instanceVariable); // 输出 2
        System.out.println("MyClass.count: " + MyClass.count); // 输出 2

        MyClass obj3 = new MyClass();
        System.out.println("obj3.instanceVariable: " + obj3.instanceVariable); // 输出 3
        System.out.println("MyClass.count: " + MyClass.count); // 输出 3
    }
}

访问方式：

静态变量可以通过类名直接访问，也可以通过类的实例访问。推荐使用类名访问，这样更清晰地表明这是一个静态变量。

System.out.println(MyClass.count); // 通过类名访问
MyClass obj = new MyClass();
System.out.println(obj.count); // 通过实例访问（不推荐）

存储位置：

静态变量存储在方法区（Method Area），这是 JVM 中一块特殊的内存区域，用于存储类的结构信息、常量、静态变量等。

初始化：

静态变量在类加载的时候初始化，并且只初始化一次。可以在声明的时候直接赋值，也可以在静态代码块中赋值。

public class StaticInitialization {
    public static int x = 10; // 声明时初始化
    public static int y;

    static {
        y = 20; // 静态代码块中初始化
    }

    public static void main(String[] args) {
        System.out.println("x: " + x); // 输出 10
        System.out.println("y: " + y); // 输出 20
    }
}

应用场景：
- 计数器： 统计类的实例数量。
- 全局常量： 定义一些不会改变的常量值。
- 配置信息： 存储应用程序的配置信息。

2. 静态方法（Static Methods）：类的“工具箱”

静态方法也用 static 关键字修饰。它们不依赖于类的任何实例，可以直接通过类名调用。静态方法就像类的“工具箱”，提供一些通用的功能，不需要创建对象就可以使用。

声明方式：

public class MyMath {
    public static int add(int a, int b) {
        return a + b;
    }

    public static void main(String[] args) {
        int sum = MyMath.add(5, 3); // 通过类名调用静态方法
        System.out.println("Sum: " + sum); // 输出 8
    }
}

访问方式：

只能通过类名直接访问，不能通过类的实例访问。

MyMath.add(1, 2); // 正确
MyMath obj = new MyMath();
// obj.add(1, 2); // 错误，编译不通过

特点：
- 静态方法不能访问非静态成员变量（实例变量），因为静态方法不属于任何实例，它不知道要访问哪个实例的变量。
- 静态方法不能调用非静态方法（实例方法），原因同上。
- 静态方法可以访问静态成员变量。
- 静态方法可以调用其他静态方法。
- 静态方法中不能使用 this 关键字，因为 this 代表当前实例，而静态方法不属于任何实例。

public class StaticMethodExample {
    private int instanceVariable = 10;
    private static int staticVariable = 20;

    public static void staticMethod() {
        // System.out.println(instanceVariable); // 错误：Cannot make a static reference to the non-static field instanceVariable
        System.out.println(staticVariable); // 正确
        staticHelperMethod(); // 正确：调用另一个静态方法
        // instanceMethod(); // 错误：Cannot make a static reference to the non-static method instanceMethod() from the type StaticMethodExample
        // System.out.println(this.instanceVariable); // 错误：Cannot use this in a static context
    }

    public void instanceMethod() {
        System.out.println(instanceVariable); // 正确
        System.out.println(staticVariable); // 正确
        staticMethod(); // 正确
    }

    private static void staticHelperMethod() {
        System.out.println("Helper method called");
    }

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

应用场景：
- 工具类方法： 提供一些通用的、与对象无关的功能，比如数学计算、字符串处理等。
- 工厂方法： 创建类的实例。
- 单例模式： 保证类只有一个实例。

3. 静态代码块（Static Blocks）：类的“初始化助手”

静态代码块用 static 关键字包裹的代码块。它在类加载的时候执行，并且只执行一次。静态代码块就像类的“初始化助手”，用于执行一些静态资源的初始化操作。

声明方式：

public class StaticBlockExample {
    public static int count;

    static {
        System.out.println("Static block executed");
        count = 100; // 初始化静态变量
    }

    public StaticBlockExample() {
        System.out.println("Constructor executed");
    }

    public static void main(String[] args) {
        System.out.println("Main method executed");
        StaticBlockExample obj = new StaticBlockExample();
        System.out.println("Count: " + count);
    }
}

执行时机：

在类加载的时候执行，并且在构造方法之前执行。如果有多个静态代码块，按照它们在类中出现的顺序依次执行。

特点：
- 静态代码块不能访问非静态成员变量。
- 静态代码块可以访问静态成员变量。
- 静态代码块不能使用 this 关键字。
应用场景：
- 加载配置文件： 从文件中读取配置信息，初始化静态变量。
- 初始化数据库连接： 创建数据库连接池。
- 执行复杂的初始化逻辑： 执行一些需要在类加载时完成的复杂操作。

4. 加载时机：一个由浅入深的过程

理解 static 关键字的关键，在于理解类加载的过程。 Java 程序在运行之前，需要将相关的类加载到 JVM 中。类加载的过程可以分为以下几个阶段：

加载（Loading）： 将类的字节码加载到 JVM 中。
链接（Linking）：
- 验证（Verification）： 确保类的字节码符合 JVM 的规范，不会造成安全问题。
- 准备（Preparation）： 为类的静态变量分配内存，并设置默认初始值（比如 0、null、false）。
- 解析（Resolution）： 将类中的符号引用转换为直接引用。
初始化（Initialization）： 执行类的静态代码块和静态变量的赋值操作。

static 关键字相关的元素，在类加载的不同阶段发挥着不同的作用：

静态变量： 在准备阶段分配内存，在初始化阶段赋值。
静态代码块： 在初始化阶段执行。
静态方法： 在类加载完成后就可以被调用。

表格总结

特性	静态变量 (Static Variables)	静态方法 (Static Methods)	静态代码块 (Static Blocks)
修饰符	`static`	`static`	`static {}`
所属	类	类	类
存储位置	方法区	方法区	方法区
加载时机	类加载的准备阶段分配内存，初始化阶段赋值	类加载完成后即可调用	类加载的初始化阶段执行
访问方式	类名或实例 (不推荐)	类名	自动执行
访问权限	可以被所有实例共享	可以直接通过类名调用	只能访问静态成员
特点	所有实例共享同一份数据	不能访问非静态成员	只能在类加载时执行一次
应用场景	计数器、全局常量、配置信息	工具类方法、工厂方法、单例模式	加载配置文件、初始化数据库连接等

注意事项

静态变量的生命周期： 静态变量的生命周期与类的生命周期相同，从类加载开始，到类卸载结束。
静态变量的线程安全： 如果多个线程同时访问和修改同一个静态变量，需要考虑线程安全问题。可以使用 synchronized 关键字或者 volatile 关键字来保证线程安全。
滥用 static： 不要滥用 static 关键字。过多的静态变量和静态方法会增加代码的耦合度，降低代码的可测试性和可维护性。

举例说明

假设我们要开发一个游戏，需要记录游戏的总玩家数量。可以使用静态变量来实现：

public class Game {
    public static int totalPlayers = 0;

    public Game() {
        totalPlayers++; // 每次创建一个游戏实例，总玩家数量加 1
    }

    public static void main(String[] args) {
        Game game1 = new Game();
        Game game2 = new Game();
        Game game3 = new Game();

        System.out.println("Total players: " + Game.totalPlayers); // 输出 3
    }
}

假设我们要开发一个数学工具类，提供一些常用的数学计算方法。可以使用静态方法来实现：

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

    public static int max(int a, int b) {
        return Math.max(a, b);
    }

    public static void main(String[] args) {
        double squareRoot = MathUtils.sqrt(16);
        int maxValue = MathUtils.max(10, 5);

        System.out.println("Square root: " + squareRoot); // 输出 4.0
        System.out.println("Max value: " + maxValue); // 输出 10
    }
}

假设我们要加载一个配置文，可以使用静态代码块来实现：

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;

public class Config {
    public static String databaseUrl;
    public static String username;
    public static String password;

    static {
        Properties properties = new Properties();
        try (FileInputStream input = new FileInputStream("config.properties")) {
            properties.load(input);
            databaseUrl = properties.getProperty("database.url");
            username = properties.getProperty("database.username");
            password = properties.getProperty("database.password");
            System.out.println("Configuration loaded successfully.");
        } catch (IOException e) {
            System.err.println("Error loading configuration: " + e.getMessage());
        }
    }

    public static void main(String[] args) {
        System.out.println("Database URL: " + databaseUrl);
        System.out.println("Username: " + username);
        System.out.println("Password: " + password);
    }
}

（创建一个名为 config.properties 的文件，内容如下：）

database.url=jdbc:mysql://localhost:3306/mydb
database.username=root
database.password=password

结语

static 关键字是 Java 中一个非常重要的概念。掌握它，你就能更好地理解 Java 的类加载机制，编写出更高效、更易于维护的代码。希望这篇文章能够帮助你更好地理解 static 这个磨人的小妖精，让它成为你代码世界里的得力助手！记住，理解概念，多加练习，才能真正掌握它。祝你编程愉快！

发表回复 取消回复

发表回复取消回复