static 变量（也称为类变量）属于类本身，而不是属于类的任何一个实例（对象）,这意味着：

1. 内存共享：一个类的所有实例共享同一个 static 变量,它在内存中只有一份拷贝。
2. 访问方式：可以通过 类名.变量名 或 对象名.变量名 的方式来访问和修改。

为 static 变量赋值主要有以下几种方式,我会按推荐的使用顺序和场景来介绍。

声明时直接赋值 (最常见)

这是最直接、最常用、最推荐的方式，在定义 static 变量时直接给出初始值。

public class Student {
    // 静态变量，属于 Student 类，所有学生对象共享这个班级号
    private static String className = "三年二班";
    private String name;
    public Student(String name) {
        this.name = name;
    }
    public void printInfo() {
        System.out.println("姓名: " + name + ", 班级: " + className);
    }
    public static void main(String[] args) {
        Student s1 = new Student("张三");
        s1.printInfo(); // 输出: 姓名: 张三, 班级: 三年二班
        Student s2 = new Student("李四");
        s2.printInfo(); // 输出: 姓名: 李四, 班级: 三年二班
        // 通过类名直接访问和修改
        System.out.println("当前班级: " + Student.className);
        Student.className = "三年三班"; // 修改了所有学生共享的班级
        s1.printInfo(); // 输出: 姓名: 张三, 班级: 三年三班
        s2.printInfo(); // 输出: 姓名: 李四, 班级: 三年三班
    }
}

特点：

• 简洁明了：代码一目了然,变量在创建时就被初始化。
• 执行时机：在类被加载到 JVM（Java 虚拟机）时，JVM 会为 static 变量分配内存并执行初始化,这个过程只发生一次。
• 适用场景：适用于所有需要固定初始值或默认值的 static 变量。

静态初始化块 (Static Initialization Block)

当一个 static 变量的初始化逻辑比较复杂，需要多行代码才能完成时，可以使用静态初始化块,静态初始化块只在类加载时执行一次。

public class DatabaseConfig {
    private static String dbUrl;
    private static String dbUser;
    private static String dbPassword;
    // 静态初始化块
    static {
        System.out.println("正在加载数据库配置...");
        // 模拟从配置文件中读取复杂的配置信息
        dbUrl = "jdbc:mysql://localhost:3306/mydb";
        dbUser = "root";
        dbPassword = "123456";
        System.out.println("数据库配置加载完成。");
    }
    public static void printConfig() {
        System.out.println("URL: " + dbUrl);
        System.out.println("User: " + dbUser);
        System.out.println("Password: " + dbPassword);
    }
    public static void main(String[] args) {
        // 第一次访问类时，静态块会执行
        DatabaseConfig.printConfig();
        System.out.println("--------------------");
        // 第二次访问类时，静态块不会再次执行
        DatabaseConfig.printConfig();
    }
}

输出:

正在加载数据库配置...
数据库配置加载完成。
URL: jdbc:mysql://localhost:3306/mydb
User: root
Password: 123456
--------------------
URL: jdbc:mysql://localhost:3306/mydb
User: root
Password: 123456

特点：

• 逻辑复杂：适用于需要执行多条语句或复杂逻辑的初始化。
• 执行时机：与声明时赋值一样，在类加载时执行一次，如果类中有多个静态块,它们会按照在代码中出现的顺序依次执行。
• 适用场景：初始化需要从文件、网络或其他复杂来源获取数据的 static 变量。

静态构造器 (Static Factory Method)

这是一种更灵活、更面向对象的方式，我们不直接暴露 static 变量，而是提供一个 public static 方法（通常称为静态工厂方法）来获取和初始化这个变量，这种方法也被称为单例模式的一种实现。

public class Logger {
    // 私有化 static 变量，防止外部直接修改
    private static Logger instance;
    // 私有化构造器，防止外部 new Logger()
    private Logger() {
        // 初始化逻辑，比如打开日志文件等
        System.out.println("Logger 实例被创建。");
    }
    // 静态工厂方法，用于获取或创建 Logger 实例
    public static Logger getInstance() {
        // 如果实例还未创建，则创建它
        if (instance == null) {
            instance = new Logger();
        }
        // 返回唯一的实例
        return instance;
    }
    public void log(String message) {
        System.out.println("[LOG] " + message);
    }
    public static void main(String[] args) {
        // 通过静态工厂方法获取实例
        Logger logger1 = Logger.getInstance();
        logger1.log("这是第一条日志。");
        // 再次调用，获取的是同一个实例
        Logger logger2 = Logger.getInstance();
        logger2.log("这是第二条日志。");
        System.out.println(logger1 == logger2); // 输出 true，证明是同一个对象
    }
}

特点：

• 封装性：static 变量可以是 private 的，通过方法来控制访问和修改,保证了封装性。
• 延迟初始化：变量（或对象）的创建可以推迟到第一次被使用时，这可以优化性能,避免不必要的资源消耗。
• 控制权：可以在方法内部加入更多的逻辑，比如线程同步、参数校验等。
• 适用场景：单例模式、需要控制对象创建逻辑的场景。

在静态方法中赋值

你也可以在任何静态方法中对 static 变量进行赋值,这种方式通常用于在程序运行过程中动态地更新类的状态。

public class GameSettings {
    private static int difficulty = 1; // 默认难度
    private static boolean soundEnabled = true;
    // 静态方法，用于设置难度
    public static void setDifficulty(int level) {
        if (level >= 1 && level <= 5) {
            difficulty = level;
            System.out.println("游戏难度已设置为: " + level);
        } else {
            System.out.println("无效的难度等级，必须是 1-5 之间的数字。");
        }
    }
    // 静态方法，用于切换声音
    public static void toggleSound() {
        soundEnabled = !soundEnabled;
        System.out.println("声音已" + (soundEnabled ? "开启" : "关闭"));
    }
    public static void printSettings() {
        System.out.println("当前设置 - 难度: " + difficulty + ", 声音: " + (soundEnabled ? "开启" : "关闭"));
    }
    public static void main(String[] args) {
        printSettings(); // 输出: 当前设置 - 难度: 1, 声音: 开启
        setDifficulty(3);
        toggleSound();
        printSettings(); // 输出: 当前设置 - 难度: 3, 声音: 关闭
    }
}

特点：

• 动态更新：可以在程序运行时根据需要修改 static 变量的值。
• 业务逻辑：常用于封装与该类状态相关的业务逻辑。
• 适用场景：当 static 变量的值需要根据程序运行状态（如用户输入、配置变更等）而改变时。

总结与最佳实践

核心要点：

1. static 变量属于类,而不是对象。
2. 初始化时机：所有静态初始化（方式1、2、3）都在类加载时完成,且只执行一次。
3. 优先使用声明时赋值：它最简单、最清晰。
4. 复杂逻辑用静态块：当初始化需要多行代码时，使用 static {} 块。
5. 考虑封装和延迟：如果需要控制实例的创建或实现单例，使用静态工厂方法（方式3）。
6. 动态更新用静态方法：如果变量值需要在运行时改变，通过静态方法来修改,这样更符合面向对象的设计原则。