java - 如何使用 Java 泛型来强制执行类型限制

Question

这题有点高级，自然也有点复杂。我会尽力做到尽可能清楚。

如标题所示，我想在从某个顶层(主要)构造对象时使用 Java 泛型来强制执行类型限制。

我从未真正使用过 Java 泛型，但我发现了一个非常好的用例，但我不确定如何实现。

我想在组合对象时强制执行类型限制。让我试着用一个例子来阐明:

我在这里有一个顶级 main 方法，我在其中调用一个 NumberEngine 对象，我在其中初始化并调用它的方法。请注意，当我调用 setExecuteBehavior() 时，我向它传递了一个 RunNumberEvaluation 类型的对象(它与 RunStringEvaluation 一起实现了一个名为 ExecutionBehavior 的接口(interface))。

顾名思义，NumberEngine 仅适用于数字而非字符串，因此我不适合将 setExecuteBehavior() 类型的对象传递给 RunStringEvaluation。我如何在编译时强制执行此行为？

public static void main(String[] args) {

    NumberEngine numberEngine = new NumberEngine();
    numberEngine.init("/path/to/forms");
    numberEngine.getEngineVesion();

    numberEngine.setExecuteBehavior(new RunNumberEvaluation);
    numberEngine.performExecution();


    // Here this should not compile, essentially throw me a compile error saying it can only accept 
    // an object of type RunNumberEvaluation, sincle NumberEngine can only run 
    // objects of type RunNumberEvaluation, etc...
    numberEngine.setExecuteBehavior(new RunStringEvaluation());
    numberEngine.performExecution();

}

所以在这里我想基本上让 NumberEngine 的 setExecuteBehavior 只接受与其相关的行为，比如处理与数字而不是字符串有关的数据。 StringEngine 反之亦然。我希望 StringEngine 只接受属于字符串而不是数字的对象。

How can I accomplish this with Java generics?

我在想这样的事情......

NumberEngine<? extends Numbers> extends Engine

甚至不确定这是否有意义...

我在下面包含了工作代码，以说明我试图传达的内容。

我有一个 Engine 类型的对象，它是一个抽象类，具有许多扩展的具体类，例如 StringEngine、NumberEngine 等。我已将算法功能解耦为一个接口(interface)，其中包含实现该接口(interface)的类。

基础抽象类

public abstract class Engine {
    ExecuteBehavior executeBehavior;

    public void setExecuteBehavior(ExecuteBehavior executeBehavior) {
        this.executeBehavior = executeBehavior;
    }
    public void performExecution() {
        executeBehavior.execute();
    }
    public abstract void init(String pathToResources);
}

具体实现类1

public class StringEngine extends Engine {
    public StringEngine() {
        executeBehavior = new RunNumberEvaluation();
    }

    @Override
    public void init(String pathToResources) {
        System.out.println("Initializing StringEngine with resources "+pathToResources);
        System.out.println("Successfully initialized StringEngine!");
    }
}

具体实现类2

public class NumberEngine extends Engine {
    public NumberEngine() {
        executeBehavior = new RunStringEvaluation();
    }

    @Override
    public void init(String pathToResources) {
        System.out.println("Initializing NumberEngine with resources "+pathToResources);
        System.out.println("Successfully initialized NumberEngine!");
    }
}

算法接口(interface)

public interface ExecuteBehavior {
    void execute();
}

算法实现1

public class RunNumberEvaluation implements ExecuteBehavior {
    @Override
    public void execute() {
        // some processing
        System.out.println("Running numeric evaluation");
    }
}

算法实现2

public class RunStringEvaluation implements ExecuteBehavior {
    @Override
    public void execute() {
        // some processing
        System.out.println("Running string evaluation");
    }
}

如果您没有注意到，我在这里使用了策略模式，在该模式中，我通过来自静态不变代码的接口(interface)将不同的算法隔离到一个系列中。

编辑:我想保留此处使用的策略模式。

Answer 1

首先将“可变”类放入引擎的正式参数列表中:

public abstract class Engine<B extends ExecuteBehavior> {
    B executeBehavior;

    public void setExecuteBehavior(B executeBehavior) {
        this.executeBehavior = executeBehavior;
    }
    public void performExecution() {
        executeBehavior.execute();
    }
    public abstract void init(String pathToResources);
}

然后你可以按照你想要的方式定义子类:

public class StringEngine extends Engine<RunStringEvaluation> {
    public StringEngine() {
        executeBehavior = new RunStringEvaluation();
    }

    @Override
    public void init(String pathToResources) {
        System.out.println("Initializing StringEngine with resources "+pathToResources);
        System.out.println("Successfully initialized StringEngine!");
    }
}

在您提供的示例代码中，您不需要它。只需将 setExecuteBehavior 移动到子类并将其设为私有(private)即可。