核心结论先行

• 静态变量：Java 中真实存在的概念，用 static 关键字修饰，它属于类，而不是类的某个实例,一个类的所有实例共享同一个静态变量。
• 全局变量：Java 中没有真正意义上的全局变量，这个概念更多是从 C/C++ 等语言借鉴过来的，在 Java 中，我们通常使用静态变量来模拟全局变量的行为，或者通过其他设计模式（如单例模式）来达到全局访问的效果。

静态变量

静态变量是类级别的一部分,而不是对象级别的一部分。

特点

1. 生命周期：静态变量的生命周期与类相同，当类被加载到 JVM 内存时，它就被创建；当类被卸载时,它才被销毁。
2. 内存位置：它存储在方法区（在 JDK 8 及之前是永久代，JDK 8+ 是元空间），而不是堆内存中,所有实例共享这一份内存。
3. 访问方式：
   • 可以通过 类名 直接访问（推荐）：ClassName.staticVariable
   • 也可以通过 对象实例 访问（不推荐，容易引起混淆）：objectInstance.staticVariable
4. 共享性：一个类的所有对象实例共享同一个静态变量，一个实例修改了它的值,其他实例看到的也会是修改后的值。

代码示例

public class Student {
    // 实例变量（每个学生有自己的名字）
    private String name;
    // 静态变量（所有学生共享同一个学校，属于类级别）
    private static String schoolName = "清华大学";
    public Student(String name) {
        this.name = name;
    }
    public void displayInfo() {
        System.out.println("姓名: " + name + ", 学校: " + schoolName);
    }
    // 静态方法，可以直接通过类名调用
    public static void changeSchool(String newSchool) {
        schoolName = newSchool;
        System.out.println("学校已更改为: " + schoolName);
    }
}
public class Main {
    public static void main(String[] args) {
        // 创建两个学生对象
        Student student1 = new Student("张三");
        Student student2 = new Student("李四");
        student1.displayInfo(); // 输出: 姓名: 张三, 学校: 清华大学
        student2.displayInfo(); // 输出: 姓名: 李四, 学校: 清华大学
        // 通过类名修改静态变量
        Student.changeSchool("北京大学");
        System.out.println("--------- 修改后 ---------");
        student1.displayInfo(); // 输出: 姓名: 张三, 学校: 北京大学
        student2.displayInfo(); // 输出: 姓名: 李四, 学校: 北京大学
        // 通过对象实例修改静态变量（不推荐）
        student1.schoolName = "复旦大学"; // 编译器会警告，因为建议用类名访问
        System.out.println("student1 看到的学校: " + student1.schoolName); // 复旦大学
        System.out.println("student2 看到的学校: " + student2.schoolName); // 复旦大学 (共享，所以也变了)
    }
}

常见用途

• 常量：用 public static final 修饰的变量，是全局常量。Math.PI，System.out。
• 计数器：记录创建了多少个对象实例。
• 共享资源：比如配置信息、数据库连接池等,所有实例都需要访问同一个资源。
• 工具类：如 java.lang.Math 中的方法,其内部使用的变量通常是静态的。

“全局变量” (Global Variable)

如前所述，Java 没有全局变量，但我们可以理解为什么需要它，以及如何在 Java 中实现类似的效果。

为什么需要全局变量？

在面向过程的语言（如 C）中，全局变量可以在任何函数中访问和修改，非常方便，在面向对象的 Java 中，过度使用全局变量会破坏封装性，导致程序难以维护和调试（因为任何地方都可能修改它，难以追踪问题）。

Java 中如何模拟全局变量？

主要有两种方式：

使用静态变量（最常见的方式）

这是最直接、最常用的方法，通过将一个变量的可见性设置为 public static,任何其他类都可以通过类名直接访问和修改它。

优点：

• 实现简单。
• 访问方便。

缺点：

• 破坏封装性：任何代码都可以修改它,可能导致数据不一致。
• 线程安全问题：如果多个线程同时修改一个静态变量,可能会导致数据错乱。
• 测试困难：代码之间耦合度高,难以进行单元测试。

示例：

// GlobalConfig.java
public class GlobalConfig {
    // 模拟全局变量
    public static String APP_VERSION = "1.0.0";
    public static String DATABASE_URL = "jdbc:mysql://localhost:3306/mydb";
}
// OtherClass.java
public class OtherClass {
    public void doSomething() {
        // 直接访问“全局”配置
        System.out.println("当前应用版本: " + GlobalConfig.APP_VERSION);
        GlobalConfig.APP_VERSION = "1.0.1"; // 修改全局配置
    }
}

使用单例模式（更优雅、更推荐）

单例模式确保一个类只有一个实例，并提供一个全局访问点来访问这个实例，这个实例内部的变量就起到了全局变量的作用,但比直接暴露的静态变量更安全。

优点：

• 封装性好：外部不能直接修改单例内部的变量,必须通过其提供的方法。
• 易于扩展：可以在单例方法中加入逻辑，如权限检查、日志记录等。
• 延迟初始化：可以在第一次使用时才创建实例,节省资源。

示例：

// AppConfig.java (单例类)
public class AppConfig {
    // 私有静态实例，防止被引用，此处赋值为null，目的是延迟加载
    private static AppConfig instance;
    // 私有构造方法，防止被实例化
    private AppConfig() {
        // 初始化配置
        this.appVersion = "1.0.0";
        this.databaseUrl = "jdbc:mysql://localhost:3306/mydb";
    }
    // 静态工程方法，创建实例
    public static synchronized AppConfig getInstance() {
        if (instance == null) {
            instance = new AppConfig();
        }
        return instance;
    }
    // 这些变量不再是 public static，而是实例变量
    private String appVersion;
    private String databaseUrl;
    // 提供公共的getter和setter方法
    public String getAppVersion() {
        return appVersion;
    }
    public void setAppVersion(String appVersion) {
        this.appVersion = appVersion;
    }
    public String getDatabaseUrl() {
        return databaseUrl;
    }
}
// OtherClass.java
public class OtherClass {
    public void doSomething() {
        // 通过单例实例访问“全局”配置
        AppConfig config = AppConfig.getInstance();
        System.out.println("当前应用版本: " + config.getAppVersion());
        // 通过setter方法修改，可以在方法中加入逻辑
        config.setAppVersion("1.0.1");
    }
}

总结与对比

最终建议：

在 Java 编程中，应谨慎使用静态变量和全局变量，它们会降低代码的模块化和可维护性，优先使用对象和方法来进行交互，遵循面向对象的设计原则（如封装、继承、多态），只有在确实需要共享状态或定义常量时，才考虑使用静态变量，并尽可能将其设为 private，通过静态方法来控制访问，如果需要全局访问一个“对象”，单例模式通常是比 public static 变量更好的选择。