Java编译期常量与运行时常量的区别详解

// 1. 基本类型字面量（最常见）
public static final int MAX_AGE = 100;
public static final boolean FLAG = true;
public static final char CH = 'A';
public static final double PI = 3.1415926;
// 2. String字面量
public static final String NAME = "Java常量";
// 3. 编译期可计算的表达式（仅包含编译期常量和合法运算符）
public static final int SUM = 10 + 20; // 编译期计算为30
public static final String COMBINE = "Hello" + "World"; // 编译期拼接为"HelloWorld"
public static final int DIFF = MAX_AGE - 50; // 引用其他编译期常量计算
public static final boolean LOGIC = FLAG && true; // 逻辑运算（不包含instanceof、++/--）
// 4. 接口中的常量（默认public static final）
interface Constant {
    String URL = "https://xxx.com"; // 编译期常量
    int TIMEOUT = 3000;
}

// 1. 引用类型（即使是包装类、枚举，也不是编译期常量）
public static final Integer NUM = 100; // Integer是引用类型，排除
public static final List<String> LIST = new ArrayList<>(); // 引用类型，排除
public static final EnumType TYPE = EnumType.A; // 枚举是引用类型，排除
// 2. 初始化值依赖运行时计算
public static final int RANDOM = new Random().nextInt(); // 运行时随机值，排除
public static final String UUID = UUID.randomUUID().toString(); // 方法调用，运行时确定
public static final int CURRENT_TIME = (int) System.currentTimeMillis(); // 运行时获取时间
// 3. 缺少static修饰（仅final修饰，无法成为编译期常量）
public final int AGE = 20; // 仅final，无static，属于运行时常量
// 4. 使用非法运算符（++/--）的表达式
public static final int COUNT = 10++; // ++是运行时自增，编译期无法计算，报错

public class CompileConstant {
    public static final int A = 5;
    public static final int B = 10;
    public static final int C = A * B + 1; // 表达式：5*10+1
}

// 常量类
public class ConstantClass {
    // 编译期常量
    public static final String COMPILE_CONST = "编译期常量";
    // 静态代码块（类初始化时执行）
    static {
        System.out.println("ConstantClass 被初始化了");
    }
}
// 测试类
public class Test {
    public static void main(String[] args) {
        // 访问编译期常量
        System.out.println(ConstantClass.COMPILE_CONST);
    }
}

// 1. 仅final修饰的实例常量（运行时常量）
public class RuntimeConstant {
    // 实例常量，每次new对象时初始化，值可不同
    public final int INSTANCE_CONST;
    // 构造方法中初始化（运行时确定值）
    public RuntimeConstant(int value) {
        this.INSTANCE_CONST = value;
    }
}
// 2. static final修饰，但初始化值依赖运行时计算
public class RuntimeConstant2 {
    // 运行时常量：值由方法调用确定（运行时计算）
    public static final int RANDOM_NUM = new Random().nextInt(100);
    // 运行时常量：值从配置文件读取（运行时加载）
    public static final String CONFIG_VALUE = readConfig("config.key");
    // 运行时常量：引用类型（枚举）
    public static final EnumType TYPE = EnumType.B;
    // 运行时常量：包装类（引用类型）
    public static final Integer WRAP_NUM = 100;
    // 静态代码块（访问时会触发执行）
    static {
        System.out.println("RuntimeConstant2 被初始化了");
    }
    // 读取配置文件的方法（运行时执行）
    private static String readConfig(String key) {
        // 模拟读取配置文件
        return "config_value";
    }
}
// 3. 局部final变量（运行时常量）
public class RuntimeConstant3 {
    public void test() {
        // 局部final变量，方法执行时初始化，属于运行时常量
        final int LOCAL_CONST = 100;
        // 局部final变量，值由参数确定（运行时传入）
        final String LOCAL_STR = new String("局部常量");
    }
}

public class Test {
    public static void main(String[] args) {
        // 访问静态运行时常量，触发类初始化
        System.out.println(RuntimeConstant2.RANDOM_NUM);
    }
}

RuntimeConstant2 被初始化了
45（随机值，每次运行可能不同）

public class MathUtil {
    // 编译期常量：固定不变，可优化
    public static final double PI = 3.1415926;
    public static final int DEFAULT_SCALE = 2;
    public static final String EMPTY_STR = "";
}

public class ConfigConstant {
    // 运行时常量：从配置文件读取（动态确定值）
    public static final String DB_URL = ConfigLoader.load("db.url");
    public static final int DB_PORT = Integer.parseInt(ConfigLoader.load("db.port"));
    // 运行时常量：引用类型（枚举）
    public static final DataSourceType DATA_SOURCE_TYPE = DataSourceType.MYSQL;
    // 实例运行时常量：每个对象独立值
    public final String INSTANCE_ID;
    public ConfigConstant(String instanceId) {
        this.INSTANCE_ID = instanceId;
    }
}

// 错误：认为这是编译期常量，实际是运行时常量
public static final Integer NUM = 100;
public static final String UUID = UUID.randomUUID().toString();

public class SerializeTest implements Serializable {
    // 错误：transient修饰编译期常量，无效
    private transient static final String SECRET = "123456";
}

public void test() {
    final int a = new Random().nextInt();
    // 错误：认为a是编译期常量，实际是运行时常量
    System.out.println(a + 10);
}

interface MyConstant {
    // 错误：认为这是编译期常量，实际是运行时常量
    String CONFIG = readConfig();
    static String readConfig() {
        return "config";
    }
}