0

对于一个项目，我想提供一个类似于工作流的通用接口，比如

public interface IWorkflow
{
    public void start();
    public void doWork();
    public void end();
}

为此，我有很多实现，比如

public class CoffeeWorkflow implements IWorkflow  
{
    public void start() 
    {
        // setup coffee
        // prepare dishes
        // ...
    }

    public void doWork()
    {
         // drink coffee
    }

    public void end()
    { 
         // wash dishes
    }
}

现在我想为这些功能提供更多信息，比如

public interface IWorkflowStartArgs
{}

特别是：

public class CoffeeWorkflowStartArgs implements IWorkflowArgs

将其放入方法中

public interface IWorkflow
{
    public void start(IWorkflowStartArgs args);
    public void doWork();
    public void end();
}

分别：

public class CoffeeWorkflow implements IWorkflow  
{
    public void start(CoffeeWorkflowStartArgs args) 
    {
    }
}

但这不起作用，因为它不被识别为接口的实现。

我应该传入一个 IWorkflowStartArgs 并将其投射到里面吗？

有没有更好的解决方案？

4

3 回答 3

3

您可以定义接口，如

interface IWorkflow<T extends IWorkflowStartArgs>
{
    public void start(T args);
    public void doWork();
    public void end();
}

当你创建时，CoffeeWorkflow你可以创建类似的东西

class CoffeeWorkflow implements IWorkflow<CoffeeWorkflowStartArgs>
{

    @Override
    public void start(CoffeeWorkflowStartArgs args) {
        // TODO Auto-generated method stub

    }

    @Override
    public void doWork() {
        // TODO Auto-generated method stub

    }

    @Override
    public void end() {
        // TODO Auto-generated method stub

    }
}
于 2013-08-13T11:00:23.540 回答
2

Java 不会将其视为特定的实现类型。考虑以下情况，您可以在其中看到问题发生的位置（如果 Java 认为函数参数中实现的类的自动映射有效）：

public class CoffeeWorkflow implements IWorkflow  
{
    public void start(IWorkflowStartArgs args) 
    {
      // This is what Java sees as actual implementation
    }

    public void start(CoffeeWorkflowStartArgs args) 
    {
       // This is yet again SEPARATE method with different signature
       // In case of auto-casting (if there would have been), this method would be AMBIGUOUS
    }
}

解决方案？

很好地使用泛型，如@sanbhat 所示

或者，如果您不想进入泛型，那么我认为您应该传入一个 IWorkflowStartArgs 并将其转换为您首先说的，就像这样：

public class CoffeeWorkflow implements IWorkflow  
{
    public void start(IWorkflowStartArgs args) 
    {
        if (args instanceof CoffeeWorkflowStartArgs) {
           CoffeeWorkflowStartArgs coffeeArgs = (CoffeeWorkflowStartArgs) args;
           // ....
        }
    }

    // ....
}

假设您有另一个类似的类 TeaWorkFlow，那么您需要再次检查instanceof. 这就是为什么主要引入泛型 - 避免重复检查instanceof; 并作为类似模式类的通用模型。

于 2013-08-13T11:19:45.570 回答
1

有一个使用单个泛型参数的解决方案，可确保类型安全。让我们为其使用通用参数 WorkflowType：

interface IWorkflow<T extends WorkflowType>
{
  public void start(IWorkflowStartArgs<T> args);
  public void doWork(IWorkflowWorkArgs<T> args);
  public void end(IWorkflowEndArgs<T> args);
}

您现在可以实例化您的泛型参数：

public class CoffeeWorkflowType extends WorkflowType {
}

您的 CoffeeWorkflow 如下所示：

public class Coffee implements IWorkflow<CoffeeWorkflowType> {
{
  public void start(IWorkflowStartArgs<CoffeeWorkflowType> args);
  public void doWork(IWorkflowWorkArgs<CoffeeWorkflowType> args);
  public void end(IWorkflowEndArgs<CoffeeWorkflowType> args);
}

以及您的工作流程参数的实现：

public class CoffeeWorkflowStartArgs implements IWorkflowStartArgs<CoffeeWorkflowType> { ... }
public class CoffeeWorkflowWorkArgs implements IWorkflowWorkArgs<CoffeeWorkflowType> { ... }
public class CoffeeWorkflowEndArgs implements IWorkflowEndArgs<CoffeeWorkflowType> { ... }
于 2013-08-13T12:07:13.337 回答