java - 在接口(interface)继承中使用 Java 泛型进行代码重用

Question

我正在尝试使用 Java 中的面向对象技术为状态机创建一个框架。每个 System 一次只能有一个 State 处于 Activity 状态。

public interface State {}
public interface System { 
    State currentState();
}

假设我想添加一种新型系统，该系统应定期更新以检查和更改其状态，称为 UpdateableSystem。它只能有 UpdateableState 类型的状态。

public interface UpdateableState extends State {
    /**
     * Check to see if the system should switch to a different state.
     * @returns new state of the system
     */
    UpdateableState update();
}

public interface UpdateableSystem extends System {
    @Override
    UpdateableState currentState();
    /** 
     * Runs update method of the current state, or otherwise updates the system.
     * @returns the current state of the system after the update
     */
    UpdateableState update();
}

我覆盖了 currentState 方法只返回 UpdateableState，而不是 State，因为 UpdateableSystem 只能具有类型为 UpdateableState 的状态，并且使用 UpdateableSystem 的客户端将期望 UpdateableState。

为了避免在创建更多子类时多次覆盖许多方法，泛型似乎是解决方案。这是更新后的界面。

public interface System<SystemState extends State> {
    SystemState currentState();
}

和

public interface UpdateableState<SystemState extends UpdateableState<SystemState>> extends State {
    SystemState update();
}

public interface UpdateableSystem<SystemState extends UpdateableState<SystemState>> extends System<SystemState> {
    SystemState update();
}

现在，假设我想添加另一种类型，即接口(interface)Context，系统和状态需要知道。 Context 应该能够被子类型化，客户端和 ContextState 子类型应该能够使用该 Context 子类型的完整接口(interface)。

public interface Context {}
public interface ContextState<SystemContext extends Context, SystemState extends ContextState<SystemContext, SystemState>> extends UpdateableState<SystemState> {
    SystemState updateWithContext(SystemContext context);
}
public interface ContextSystem<SystemContext extends Context, SystemState extends ContextState<SystemContext, SystemState>> extends UpdateableSystem<SystemState> {
    // Some methods here that require SystemContext type
}

突然间，那些参数化类型变成了一大堆样板，令人困惑且难以维护。

这将是一个具体实现的例子:

class CarContext implements Context {...}
interface CarState extends ContextState<CarContext, CarState> {...}
    class CarDrivingState implements CarState {}
    class CarIdleState implements CarState {}
class Car implements ContextSystem<CarContext, CarState> {...}

每个具体的 CarState 都能够访问 CarContext 接口(interface)提供的附加方法，因为从 ContextState 继承的方法签名将是由 CarContext 类型参数化。因此，不需要对 updateWithContext 的上下文参数进行显式转换。

最终，问题是在添加额外类型参数化时样板太多，我不知道有什么设计替代方案可以通过继承实现代码重用，同时保持强类型系统，尽可能避免显式转换。有什么改进此设计的建议吗？

Answer 1

在花了一天的时间思考这个问题并稍微尝试一下您的示例代码之后，我认为您已经找到了解决这个问题的最佳方法，尽管您可能会从适当遵守 Java Generics code style standards 中获益。 .

通过在接口(interface)声明中使用通用类型的全名，实际上会使它们更难阅读，尤其是在涉及方法时。泛型类型很容易与实际的接口(interface)或类名称混淆。更不用说它们占用更多空间了。让我们看看您的代码遵循标准会是什么样子:

public interface State{}
public interface System<S extends State> {
    S currentState();
}

public interface UpdateableState<S extends UpdateableState<S>> extends State {
    S update();
}
public interface UpdateableSystem<S extends UpdateableState<S>> extends System<S> {
    S update();
}

public interface Context{}
public interface ContextState<C extends Context, S extends ContextState<C, S>> extends UpdateableState<S> {
    S updateWithContext(C context);
}
public interface ContextSystem<C extends Context, S extends ContextState<C, S>> extends UpdateableSystem<S> {
    // Some methods here that require SystemContext type
}

class CarContext implements Context {...}
interface CarState extends ContextState<CarContext, CarState> {...}
class CarDrivingState implements CarState {}
class CarIdleState implements CarState {}
class Car implements ContextSystem<CarContext, CarState> {...}

声明仍然很冗长，但不那么冗长了。此外，我们现在可以明确区分完整引用类型参数和泛型类型参数。

最重要的是该解决方案有效。

---

但是，如果您想进一步简化它，您可以这样做，但可能会冒着这些接口(interface)被滥用的风险。例如:

public interface State{}
public interface System<S> {
    S currentState();
}

public interface UpdateableState<S> extends State {
    S update();
}
public interface UpdateableSystem<S> extends System<S> {
    S update();
}

public interface Context{}
public interface ContextState<C, S> extends UpdateableState<S> {
    S updateWithContext(C context);
}
public interface ContextSystem<C, S> extends UpdateableSystem<S> {
    S updateWithContext(C context);
}

public class ExampleContext implements Context{}
public class ExampleContextState implements ContextState<ExampleContext, ExampleContextState>{
    @Override
    public ExampleContextState updateWithContext(ExampleContext context)
    {
        return this;
    }

    @Override
    public ExampleContextState update()
    {
        return this;
    }
}
public class ExampleContextSystem implements ContextSystem<ExampleContext, ExampleContextState>{
    private ExampleContextState currentState;
    public ExampleContextSystem(){
        currentState = new ExampleContextState();
    }
    @Override
    public ExampleContextState updateWithContext(ExampleContext context)
    {
        this.currentState = currentState.updateWithContext(context);
        return currentState;
    }

    @Override
    public ExampleContextState update()
    {
        this.currentState = currentState.update();
        return currentState;
    }

    @Override
    public ExampleContextState currentState()
    {
        return currentState;
    }

}

在这里，我认为接口(interface)声明大大减少了。这里的一切都像以前一样顺利。问题是有人可以去做一些愚蠢的事情，比如......

public class BadExampleContextState implements ContextState<Integer, String>{
    @Override
    public String updateWithContext(Integer context)
    {
        return "Garbage";
    }

    @Override
    public String update()
    {
        return "Garbage";
    }
}

幸运的是，这种误用并没有真正进入我们的 ExampleContextSystem，所以我们仍然不能最终尝试将 String 分配给 ExampleContextState 引用，但它仍然表明我们已经失去了对如何使用这些接口(interface)的一些控制。尽管如此，即使我们制作一个通用的具体系统类......

public class GenericSystem<S extends UpdateableState<S>> implements UpdateableSystem<S>{
    private S currentState;
    public GenericSystem(S startingState){
        this.currentState = startingState;
    }
    @Override
    public S update()
    {
        this.currentState = currentState.update();
        return currentState;
    }

    @Override
    public S currentState()
    {
        return currentState;
    }

}

类型系统仍然足够强大，可以防止我们爆炸......

GenericSystem<BadExampleContextState> s = new GenericSystem<>(new BadExampleContextState()); 
// error: type argument Generics.BadExampleContextState is not within bounds of type-variable S

TL;DR:我认为您最好放宽您的通用约束，提供不那么冗长的接口(interface)声明，而不会承担太多(如果有的话)运行时失败的风险。