Java中static关键字的用法与场景深入理解

修饰符 static 数据类型 变量名 = 初始值;

public class Student {
    // 实例变量：每个对象独有一份
    private String name;
    // 静态变量：所有Student对象共享
    public static String school = "北京大学";

    // 构造方法
    public Student(String name) {
        this.name = name;
    }

    public static void main(String[] args) {
        // 无需创建对象，直接通过类名访问静态变量
        System.out.println(Student.school);

        // 创建两个对象
        Student s1 = new Student("张三");
        Student s2 = new Student("李四");

        // 两个对象共享同一个静态变量
        System.out.println(s1.school); // 北京大学
        System.out.println(s2.school); // 北京大学

        // 修改静态变量，所有对象的school都会改变
        Student.school = "清华大学";
        System.out.println(s1.school); // 清华大学
        System.out.println(s2.school); // 清华大学
    }
}

修饰符 static 返回值类型 方法名(参数列表) { 方法体 }

public class StaticMethodDemo {
    // 静态变量
    private static int count = 0;
    // 实例变量
    private String msg = "hello";

    // 静态方法
    public static void addCount() {
        // 正确：静态方法访问静态变量
        count++;
        // 错误：静态方法不能直接访问实例变量
        // System.out.println(msg);
        // 错误：静态方法不能使用this
        // this.count++;
    }

    // 实例方法
    public void show() {
        // 正确：实例方法可以访问静态成员
        System.out.println(count);
        // 正确：实例方法可以访问实例成员
        System.out.println(msg);
    }

    public static void main(String[] args) {
        // 直接通过类名调用静态方法
        StaticMethodDemo.addCount();
        System.out.println(StaticMethodDemo.count); // 1
    }
}

static {
    // 代码逻辑
}

public class StaticBlockDemo {
    public static String info;

    // 静态代码块：类加载时执行，用于初始化静态资源
    static {
        info = "静态代码块初始化";
        System.out.println("静态代码块执行");
    }

    // 构造方法
    public StaticBlockDemo() {
        System.out.println("构造方法执行");
    }

    public static void main(String[] args) {
        // 第一次创建对象：类加载→静态代码块→构造方法
        new StaticBlockDemo();
        // 第二次创建对象：只执行构造方法（静态代码块只执行一次）
        new StaticBlockDemo();
    }
}

静态代码块执行
构造方法执行
构造方法执行

public class OuterClass {
    private static String outerStatic = "外部类静态变量";
    private String outerInstance = "外部类实例变量";

    // 静态内部类
    public static class StaticInnerClass {
        public void show() {
            // 正确：访问外部类静态成员
            System.out.println(outerStatic);
            // 错误：不能访问外部类实例成员
            // System.out.println(outerInstance);
        }
    }

    public static void main(String[] args) {
        // 直接创建静态内部类对象，无需创建外部类对象
        OuterClass.StaticInnerClass inner = new OuterClass.StaticInnerClass();
        inner.show();
    }
}