相关疑难解决方法(0)

我有一个init方法,通过广泛的层次结构使用和覆盖.然而,每个init调用都扩展了之前的工作.很自然地,我愿意:

@Override public void init() {
   super.init();
}

当然,这将确保一切都被调用和实例化.我想知道的是:我可以创建一种方法来确保调用超级方法吗？如果所有的init都没有调用,那么obejct就会出现故障,所以如果有人忘记调用,我想抛出异常或错误super.

TYFT~Aedon

假设我需要一些DerivedBuilder扩展一些BaseBuilder.基础构建器有一些方法foo(返回BaseBuilder).派生构建器有方法bar.方法bar应方法之后被调用foo.为了做到这一点,我可以像这样覆盖foo方法DerivedBuilder:

@Override
public DerivedBuilder foo() {
    super.foo();
    return this;
}

问题是BaseBuilder有很多方法foo,我必须覆盖它们中的每一个.我不想这样做,所以我尝试使用泛型:

public class BaseBuilder<T extends BaseBuilder> {
    ...

    public T foo() {
        ...
        return (T)this;
    }
}

public class DerivedBuilder<T extends DerivedBuilder> extends BaseBuilder<T> {
    public T bar() {
        ...
        return (T)this;
    }
}

但问题是我还是不能写

new DerivedBuilder<DerivedBuilder>()
        .foo()
        .bar()

即使T这是DerivedBuilder.为了不覆盖很多功能,我该怎么办？

我正在尝试找到一种最优雅的方式来允许孩子和父母对祖父母发起的事件做出反应。这是一个天真的解决方案：

abstract class A {
    final public void foo() {
        // Some stuff here
        onFoo();
    }

    protected abstract void onFoo();
}

abstract class B extends A {
    @Override
    final protected void onFoo() {
        // More stuff here
        onOnFoo();
    }

    protected abstract void onOnFoo();
}

class C extends B {
    @Override
    protected void onOnFoo() {
        // Even more stuff here
    }
}

因此，基本上，我正在尝试找到一种最佳方法，以便在调用foo（）时允许所有相关类执行某些逻辑。为了稳定和简单起见，我希望所有步骤都按顺序完成，尽管这不是必需的。

我发现的另一种解决方案涉及将所有事件处理程序存储为某种形式的Runnable：

abstract class A {
    private ArrayList<Runnable> fooHandlers = new ArrayList<>();

    final public void foo() {
        // Some …