Java Static关键字详解

静态变量

静态的内容可以理解为是属于类的，是所有对象共享的。我们使用static关键字来声明。

public class Person {
    String name;
    int age;
    static String info; // 静态变量
}

一个对象改变了静态变量的值，其他对象读取的就是被改变的值。

public static void main(String[] args) {
    Person p1 = new Person();
    Person p2 = new Person();
    p1.info = "info:1";
    System.out.println(p2.info); // 输出: info:1
}

通常，我们通过类名来访问静态成员：

public static void main(String[] args) {
    Person.info = "info:2";
    System.out.println(Person.info);
}

静态方法

静态方法同样属于类，而不是具体的某个对象。

static void test(){
    System.out.println("我是静态方法");
}

在静态方法中，无法直接访问非静态的成员变量或使用this关键字，因为它们都与具体对象相关。但是，静态方法可以访问静态变量。

static String info;

static void test(){
    System.out.println("静态变量的值为："+info);
}

静态(有static) vs 非静态(无static)对比

理解静态成员和非静态成员的根本区别是掌握Java面向对象编程的关键。

public class Student {
    // 静态成员 - 属于类
    static int totalCount = 0;         // 静态变量
    static String schoolName = "浙大城市学院"; // 静态变量
    
    // 非静态成员 - 属于对象实例
    String name;                       // 实例变量
    int age;                           // 实例变量
    
    // 静态方法 - 属于类
    static void printSchoolInfo() {
        System.out.println("学校：" + schoolName);
        System.out.println("总学生数：" + totalCount);
        // 错误：不能直接访问实例变量
        // System.out.println(name); // 编译错误！
    }
    
    // 非静态方法 - 属于对象实例
    void printStudentInfo() {
        System.out.println("姓名：" + name);
        System.out.println("年龄：" + age);
        // 可以访问静态变量
        System.out.println("学校：" + schoolName);
        System.out.println("总学生数：" + totalCount);
    }
    
    // 构造方法
    Student(String name, int age) {
        this.name = name;
        this.age = age;
        totalCount++; // 每创建一个学生，总数+1
    }
}

public class TestStudent {
    public static void main(String[] args) {
        // 访问静态成员 - 不需要创建对象
        System.out.println("初始学生总数：" + Student.totalCount); // 输出：0
        Student.printSchoolInfo(); // 直接通过类名调用
        
        // 创建对象实例
        Student s1 = new Student("张三", 20);
        Student s2 = new Student("李四", 21);
        
        // 访问实例成员 - 必须通过对象
        s1.printStudentInfo();
        s2.printStudentInfo();
        
        // 静态成员被所有对象共享
        System.out.println("当前学生总数：" + Student.totalCount); // 输出：2
        System.out.println("通过s1访问：" + s1.totalCount);       // 输出：2 (不推荐)
        System.out.println("通过s2访问：" + s2.totalCount);       // 输出：2 (不推荐)
    }
}

静态变量动画演示

静态变量属于类，被所有对象实例共享。让我们通过动画来理解这个概念：

静态代码块和初始化顺序

静态代码块可用于初始化静态变量，它在类加载时执行。

public class Person {
    String name = test();

    {
        System.out.println("我是普通代码块");
    }

    Person() {
        System.out.println("我是构造方法");
    }

    String test() {
        System.out.println("我是成员变量初始化");
        return "小明";
    }

    static String info = init();

    static {
        System.out.println("我是静态代码块");
    }

    static String init() {
        System.out.println("我是静态变量初始化");
        return "test";
    }
}

当创建一个对象时，执行顺序如下：

1. 我是静态变量初始化
2. 我是静态代码块
3. 我是成员变量初始化
4. 我是普通代码块
5. 我是构造方法

如果只访问静态成员（如Person.info），则只会执行静态部分的初始化。

static成员的完整生命周期

从类加载到程序结束，理解static成员在内存中的完整生命历程。

static成员的完整生命周期（续）

通过执行输出分析和类加载触发时机，深入理解static成员的行为特点。

public class LifecycleDemo {
    // 静态变量 - 在类加载时初始化
    static String staticVar = initStaticVar();
    
    // 静态代码块 - 在类加载时执行
    static {
        System.out.println("3. 静态代码块执行");
    }
    
    // 实例变量 - 在对象创建时初始化
    String instanceVar = initInstanceVar();
    
    // 实例代码块 - 在对象创建时执行
    {
        System.out.println("6. 实例代码块执行");
    }
    
    // 静态方法 - 用于初始化静态变量
    static String initStaticVar() {
        System.out.println("2. 静态变量初始化");
        return "静态变量值";
    }
    
    // 实例方法 - 用于初始化实例变量
    String initInstanceVar() {
        System.out.println("5. 实例变量初始化");
        return "实例变量值";
    }
    
    // 构造方法
    public LifecycleDemo() {
        System.out.println("7. 构造方法执行");
    }
    
    public static void main(String[] args) {
        System.out.println("1. 开始执行main方法");
        
        System.out.println("4. 准备创建第一个对象");
        LifecycleDemo obj1 = new LifecycleDemo();
        
        System.out.println("8. 准备创建第二个对象");
        LifecycleDemo obj2 = new LifecycleDemo();
        
        System.out.println("9. 程序结束");
    }
}

// 1. 创建类的实例
MyClass obj = new MyClass();

// 2. 访问或设置类的静态变量（非final常量）
int value = MyClass.staticVar;
MyClass.staticVar = 100;

// 3. 调用类的静态方法
MyClass.staticMethod();

// 4. 使用反射
Class.forName("com.example.MyClass");

// 5. 初始化子类时，ParentClass会先被加载
ChildClass child = new ChildClass(); 

// 1. 访问静态final常量
String constant = MyClass.STATIC_FINAL_STRING; 

// 2. 通过数组定义引用类
MyClass[] array = new MyClass[10]; 

// 3. 访问父类的静态成员，只加载父类
String parentVar = ChildClass.parentStaticVar; 

JVM内存模型与Static成员存储

从虚拟机角度深入理解static成员与类的关联，以及非静态成员与对象的关联。

交互式内存分配演示

通过动画直观理解static成员与实例成员在JVM内存中的分配过程。

public class AnimationDemo {
    static String staticVar = "静态变量";
    static int counter = 0;
    
    String instanceVar;
    int id;
    
    public AnimationDemo(String name) {
        this.instanceVar = name;
        this.id = ++counter;
    }
    
    public static void main(String[] args) {
        AnimationDemo obj1 = new AnimationDemo("对象1");
        AnimationDemo obj2 = new AnimationDemo("对象2");
    }
}