Java 静态机制之静态变量、方法、代码块与类加载深入理解

public class Demo {
    public static String from = "默认值";
}
public class TestConfigParser {
    public static void main(String[] args) {
        Demo demo = new Demo();
        Demo demo1 = new Demo();
        Demo demo2 = new Demo();
        demo.from = "中国"; // 修改静态变量
        System.out.println(demo.from);   // 输出：中国
        System.out.println(demo1.from);  // 输出：中国（所有对象共享）
        System.out.println(demo2.from);  // 输出：中国（所有对象共享）
    }
}

public class MathUtil {
    // 静态方法：工具类方法，无需依赖对象状态
    public static int add(int a, int b) {
        return a + b;
    }
}
public class Test {
    public static void main(String[] args) {
        // 直接通过类名调用静态方法，无需创建对象
        int result = MathUtil.add(3, 5);
        System.out.println(result); // 输出：8
    }
}

public class Demo {
    private int instanceVar = 10; // 实例变量
    private static int staticVar = 20; // 静态变量
    // 静态方法
    public static void staticMethod() {
        // 编译错误：静态方法不能直接访问实例变量
        // System.out.println(instanceVar);
        // 可以访问静态变量
        System.out.println(staticVar); // 输出：20
        // 编译错误：静态方法中不能使用this
        // System.out.println(this.instanceVar);
    }
    // 非静态方法
    public void instanceMethod() {
        // 可以访问实例变量和静态变量
        System.out.println(instanceVar); // 输出：10
        System.out.println(staticVar);   // 输出：20
        // 可以使用this
        System.out.println(this.instanceVar); // 输出：10
    }
}

public class Demo {
    static {
        System.out.println("静态代码块1：类加载时执行，仅一次");
    }
    public static Demo demo = new Demo("静态成员初始化");
    static {
        System.out.println("静态代码块2：类加载时执行，仅一次");
    }
    public Demo(String msg) {
        System.out.println("构造方法：" + msg);
    }
}
public class Test {
    public static void main(String[] args) {
        System.out.println("开始创建对象");
        Demo demo = new Demo("main方法中创建对象");
    }
}

class Base {
    static {
        System.out.println("base static：父类静态代码块");
    }
    public Base() {
        System.out.println("base constructor：父类构造方法");
    }
}
public class Test extends Base {
    static {
        System.out.println("test static：子类静态代码块");
    }
    public Test() {
        System.out.println("test constructor：子类构造方法");
    }
    public static void main(String[] args) {
        new Test();
    }
}

public class StringUtil {
    // 静态方法：判断字符串是否为空
    public static boolean isEmpty(String str) {
        return str == null || str.trim().length() == 0;
    }
    // 静态方法：字符串转整数，带默认值
    public static int toInt(String str, int defaultValue) {
        if (isEmpty(str)) {
            return defaultValue;
        }
        try {
            return Integer.parseInt(str);
        } catch (NumberFormatException e) {
            return defaultValue;
        }
    }
}
// 调用示例
public class Test {
    public static void main(String[] args) {
        System.out.println(StringUtil.isEmpty("")); // 输出：true
        System.out.println(StringUtil.toInt("123", 0)); // 输出：123
        System.out.println(StringUtil.toInt("abc", 0)); // 输出：0
    }
}

public class Singleton {
    // 静态变量：类加载时初始化唯一实例
    private static final Singleton INSTANCE = new Singleton();
    // 私有构造方法：防止外部创建对象
    private Singleton() {}
    // 静态方法：提供全局访问点
    public static Singleton getInstance() {
        return INSTANCE;
    }
    // 业务方法
    public void doSomething() {
        System.out.println("单例对象的业务逻辑");
    }
}
// 调用示例
public class Test {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2); // 输出：true（同一实例）
    }
}