Question

因此，我正在尝试设计一个小的基本抽象类：

public abstract class BaseClass
{
    abstract void reload();


    protected BaseClass()
    {
        reload();
        // schedule reload for every X minutes
    }
}

现在，子类：

class SubClass extends BaseClass
{
    private int member = 5;

    @Override
    void reload()
    {
        member = 20;
    }
}

现在，我面临的问题是在初始化成员之前调用reload（）方法。因此，给成员分配20，然后分配值5（当然，这只是一个示例，实际代码不同，但思路相同）。我要达到的最佳设计是什么？我希望初始化的顺序是-成员分配5，并且如果reload（）由于某种原因失败，我希望它保持初始值。但是，在此代码中，5会覆盖reload（）的值。如果我不为实例成员分配初始值，那当然可以。我可能要问什么？

Answer 1

您可以使用构建器来实现。

这样，您就可以实现完全控制。

public abstract class Foo {

    public abstract void postConstruct();

    public static void main(String[] args) {
        Bar bar = Foo.build(Bar.class);
        System.out.println(bar);

    }

    public static <T extends Foo> T build(Class<T> clazz) {
        T obj;
        try {
            obj = clazz.newInstance();
            obj.postConstruct();
            return obj;
        } catch (Exception e) {
            throw new IllegalArgumentException(
                  "Class "+clazz.getName()+" is not a valid class",e);
        }
    }

}


public class Bar extends Foo {

    int value = 10;

    protected Bar() {
        super();
    }

    public void postConstruct() {
        value = 7;
    }


    @Override
    public String toString() {
        return "Bar [value=" + value + "]";
    }

}

Answer 2

重写构造函数并在那里调用reload（），但不要调用super（），由于其他原因，这可能是不可接受的：）

class SubClass { 
    private int member = 5;

    public SubClass() {
        reload();
    }
    ...
}

构造函数，从基调用的子类方法和实例成员顺序初始化问题

2 个答案: