最初我在 CodeReview 上发布了问题，但这可能更适合 StackOverflow。

我正在使用 Java 6 编写一个多步骤过程的代码。假设有 3 个步骤。
每个接受相同类型的输入。 让我们开始吧。

这是作为输入传递给每个步骤的对象。该对象充当另一种类型对象的包装器，以及一些步骤的共享值。 请注意名称被翻译成更通用的域和英语，原件是意大利语。

public class EntityStepInput<T extends Entity> {
    public final T entity;
    public boolean modified;
    public boolean canceled;

    public EntityStepInput(final T entity) {
        this.entity = entity;
    }
}

这是每个步骤使用的接口(interface)。

public interface EntityStep<T extends EntityStepInput<? extends Entity>> {
    void process(final T stepInput) throws Exception;
}

现在，3 个步骤中的 2 个必须接受一个 EntityStepInput，它包含一个 Entity 或从它派生的任何类型。

public class FirstEntityStep implements EntityStep<EntityStepInput<? extends Entity>> {
    @Override
    public void process(final EntityStepInput<? extends Entity> stepInput) throws Exception {}
}

public class SecondEntityStep implements EntityStep<EntityStepInput<? extends Entity>> {
    @Override
    public void process(final EntityStepInput<? extends Entity> stepInput) throws Exception {}
}

最后一步必须接受 EntityStepInput，其中包含从 Entity 派生的特定类型。

public class ThirdEntityStep implements EntityStep<EntityStepInput<? extends DerivedEntity>> {
    @Override
    public void process(final EntityStepInput<? extends DerivedEntity> stepInput) throws Exception {}
}

用法非常简单。我有接受不同类型的 Entity 的重载方法。以下是简化版。

public void workWithEntity(final DerivedEntity entity) throws Exception {
    final EntityStepInput<DerivedEntity> stepInput = new EntityStepInput<DerivedEntity>(entity);

    stepOne.process(stepInput);
    stepTwo.process(stepInput);
    stepThree.process(stepInput);
}

如您所见，DerivedEntity 类型能够使用所有步骤。

public void workWithEntity(final OtherDerivedEntity entity) throws Exception {
    final EntityStepInput<OtherDerivedEntity> stepInput = new EntityStepInput<OtherDerivedEntity>(entity);

    stepOne.process(stepInput);
    stepTwo.process(stepInput);
}

而这里另一种类型的Entity不能使用最后一步，这正是我想要的。

现在，这对于泛型来说已经变得相当复杂了。我担心在我离开后谁会看不懂我的代码，迟早会弄得一团糟。

这可以简化吗？尽可能尊重单一职责原则的方法是什么？

编辑。 实体层次结构如下:

Entity > DerivedEntity
Entity > OtherDerivedEntity

最佳答案

这是我第二次尝试回答。我认为您目前使用的系统看起来不错；它提供编译时检查，因为您不想让第 3 步尝试处理任何不是 DerivedEntity 的类型。 (或其子项之一)。

您可以使用 List<Consumer<? extends Entity>> 来简化它，但是您丢失了步骤 #3 的编译时类型检查，并且被迫使用 instanceof 来改善它:

Java 8+ 解决方案:

List<Consumer<Entity>> processes = new ArrayList<>();

processes.add(entity -> {
    // Process first step.
});

processes.add(entity -> {
    // Process second step.
});

processes.add(entity -> {
    if (!(entity instanceof DerivedEntity)) {
        System.out.println("Step 3: The entity must be a DerivedEntity!");
        return;
    }
    // Process third step.
});

传递 Entity通过管道，它很简单:

processes.forEach(consumer -> consumer.accept(entity));

Java 6+ 解决方案(让我们创建自己的 Consumer 界面!):

public interface Consumer<T> {
    void accept(T t);
}

与上面相同的代码，但使用我们的 Consumer接口(interface):

List<Consumer<Entity>> processes = new ArrayList<Consumer<Entity>>();

processes.add(new Consumer<Entity>() {
    @Override
    public void accept(Entity entity) {
        // Process first step.
    }
});

processes.add(new Consumer<Entity>() {
    @Override
    public void accept(Entity entity) {
        // Process second step.
    }
});

processes.add(new Consumer<Entity>() {
    @Override
    public void accept(Entity entity) {
        if (!(entity instanceof DerivedEntity)) {
            System.out.println("Step 3: The entity must be a DerivedEntity!");
            return;
        }
        // Process third step.
    }
});

Entity entity = new DerivedEntity();

for (Consumer<Entity> consumer : processes) {
    consumer.accept(entity);
}

关于Java 泛型 - 太复杂？如何简化？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/51340234/