Java中无需final关键字且不在构造器赋值，如何实现变量仅赋值一次？

没问题！在Java里，除了final关键字，确实有办法实现「变量仅能被赋值一次」的需求，而且不需要在构造阶段就确定变量的值——刚好匹配你说的「暂时不知道值」的场景。下面给你几种实用的方案：

1. 自定义单赋值Holder类（最直观的方案） #

自己写一个简单的包装类，通过内部标志位控制赋值次数，这是最灵活也最容易理解的方式。

基础版本（单线程场景） #

public class OneTimeVar<T> {
    private T value;
    private boolean hasAssigned = false;

    // 仅允许第一次赋值成功，后续赋值抛出异常
    public void set(T newValue) {
        if (hasAssigned) {
            throw new IllegalStateException("这个变量只能被赋值一次！");
        }
        this.value = newValue;
        this.hasAssigned = true;
    }

    // 获取值前检查是否已赋值
    public T get() {
        if (!hasAssigned) {
            throw new IllegalStateException("变量还未被赋值！");
        }
        return this.value;
    }
}

使用示例：

OneTimeVar<String> myVar = new OneTimeVar<>();
// 第一次赋值正常
myVar.set("我是第一次赋值的内容");
System.out.println(myVar.get()); // 输出：我是第一次赋值的内容

// 第二次赋值会抛出异常
myVar.set("想覆盖？没门！"); // 抛出IllegalStateException

如果你不想抛出异常，也可以改成静默忽略赋值请求（不过不推荐，容易隐藏bug）。

线程安全版本（多线程场景） #

如果你的变量会在多线程环境下被赋值，需要用原子类保证线程安全：

import java.util.concurrent.atomic.AtomicBoolean;

public class ThreadSafeOneTimeVar<T> {
    private T value;
    private final AtomicBoolean hasAssigned = new AtomicBoolean(false);

    // 返回true表示赋值成功，false表示已被赋值过
    public boolean set(T newValue) {
        // CAS操作保证原子性：只有当hasAssigned为false时，才改为true并赋值
        if (hasAssigned.compareAndSet(false, true)) {
            this.value = newValue;
            return true;
        }
        return false;
    }

    public T get() {
        if (!hasAssigned.get()) {
            throw new IllegalStateException("变量还未被赋值！");
        }
        return this.value;
    }
}

2. 利用Supplier接口封装（轻量方案） #

如果不想单独写一个类，也可以用Java自带的Supplier接口做封装，本质和Holder类逻辑一致：

import java.util.function.Supplier;

final Supplier<String> lazyOneTimeVar = new Supplier<>() {
    private String value;
    private boolean assigned = false;

    @Override
    public String get() {
        if (!assigned) {
            throw new IllegalStateException("未赋值");
        }
        return value;
    }

    public void set(String newValue) {
        if (assigned) {
            throw new IllegalStateException("已赋值，无法修改");
        }
        this.value = newValue;
        this.assigned = true;
    }
};

// 使用方式
lazyOneTimeVar.set("延迟赋值的内容");
System.out.println(lazyOneTimeVar.get());

注意事项和小建议 #

• 这些方案都是运行时检查，不像final是编译时检查——也就是说，编译器不会帮你提前发现重复赋值的错误，只有运行时才会报错。所以如果你的业务逻辑可以调整为用final（比如在确定值后再初始化变量），还是优先用final，它更安全也更符合Java的设计规范。
• 如果你用的是第三方库（比如Guava），也可以直接用com.google.common.base.Suppliers.memoize或者Immutable相关类，但原生Java的话上面的方案就足够了。

内容的提问来源于stack exchange，提问作者Makusium