java - 在延迟初始化和一般情况下，覆盖可以有效替代 if 语句吗？

Question

我试图模仿以下抽象类，旨在仅启用一次延迟初始化，而不使用逻辑语句。为了简单起见，我忽略了线程安全所需的同步元素。

abstract class Thunk<T>
{
    private boolean initiated = false;
    private T value;

    public T get()
    {
        if(!initiated) // not using (value == null)
        {
            value = compute();
            initiated = true;
        }

        return value;
    }

    abstract protected T compute();
}

子级可以攻击以下抽象类的实例来多次初始化同一变量吗？

abstract class Thunk<T>
{
    private T value;
    private Computer<T> computer;

    public Thunk()
    {
        computer = new Computer<T>(this);
    }

    public T get()
    {
        value = computer.getValue();    
        return value;
    }

    abstract protected T compute();

    private class Computer<T> 
    {
        private static final String TAG = "Computer";

        private Thunk<T> thunk;
        private T value;
        private Computer<T> computer;

        public Computer(Thunk<T> thunk)
        {
            Log.d(TAG, "constructed");
            this.thunk = thunk;
            computer = this;
        }

        public T getValue() 
        {
            Log.d(TAG + ".getValue()", "");
            value = computer.computeValue();
            return value;
        }

        protected T computeValue() 
        {
            Log.d(TAG + ".computeValue()", "");
            value = thunk.compute();
            computer = new DumbComputer<T>(thunk, value);
            return value;
        }

        //this is for maximal encapsulation
        private class DumbComputer<T> extends Computer<T>
        {
            private static final String TAG = "DumbComputer";
            private T value;

            public DumbComputer(Thunk<T> thunk, T value) 
            {
                super(thunk);
                Log.d(TAG + ".contructed()", "booki");
                this.value = value; 
            }

            //overriding so that value will be calculated only once.
            @Override
            protected T computeValue() 
            {
                Log.d(TAG + ".computeValue()", "");
                return value;
            }
        }

    }
}

Answer 1

是的，通过重写 get 方法。

要解决此问题，您可以将 get 设为 final 方法。这将防止覆盖并为您提供类似单例的行为。

请注意，您编写的代码不是线程安全的。

您可以通过使方法同步来实现线程安全(不要担心性能直到您知道您遇到了问题并且该方法是热点，因为慢的正确代码比快的错误代码要好，而且 JVM 非常擅长优化锁。如果你发现这个类的某个特定锁过热，你可以使用一些技巧来加快它的速度...但暂时不用担心)

还值得指出的是，如果您想要单例的最佳惰性初始化，则可以使用惰性初始化的资源持有者内部类模式(不适用于您的用例，因为此类需要。它仅用于单例)。

更新(回复评论，因为评论不支持格式)

这样做:

abstract class Thunk<T>
{
    private boolean initiated = false;
    private T value;

    public synchronized final T get()
    {
        if(!initiated) // not using (value == null)
        {
            value = compute();
            initiated = true;
        }

        return value;
    }

    abstract protected T compute();
}

这是可以工作的最简单的代码。甚至不要梦想尝试“改进”该代码。它可以改进，但改进会根据类的使用方式而有所不同，并且改进的复杂性将隐藏您的代码试图执行的操作。从最简单可行的事情开始，然后从那里开始。

保持简单愚蠢

不要解决你还没有遇到的问题