如何在 Java 中抽象出不同的返回类型？

Question

我猜这是某种设计模式问题。

我想将几个操作（输入 + 处理逻辑 + 输出）建模为实现一些 IOperation 接口的类。

每个操作可能有不同的输入参数和不同的输出参数。

我可以使用每个操作的构造函数为每个操作指定不同的输入。

但我也希望以正交方式为每个类获得不同的输出，而不必将接口转换为具体类。

对此的明显方法是 [1] 转换为具体类并调用返回所需结果的特定方法或 [2] 将结果包装到某个 OperationResult 对象中，这反过来也需要向下转换或一些元数据信息 + 提取器代码。

我想避免处理反射或向下转换或元数据解释。

在 Java 中是否有针对这种情况的已知设计？对此有什么好的方法？

更新 - @Laf，这里有一些具体的例子。我想提取“c”

interface IOperation{
    void execute();
}

public class AddOp implements IOperation{

    private int a;
    private int b;
    private int c;

    public AddOp(int a, int b){
        this.a = a;
        this.b = b;
    }

    @Override
    public void execute() {
        this.c = this.a + this.b;
    }

}

public class AndOp implements IOperation{

    private boolean a;
    private boolean b;
    private boolean c;

    public AndOp(boolean a, boolean b){
        this.a = a;
        this.b = b;
    }

    @Override
    public void execute() {
        this.c = this.a && this.b;
    }

}

Answer 1

看起来你可以使用double dispatching。

您返回 void 并作为参数传递您希望将结果放入的目标对象，而不是返回值（即 Object）。

interface ResultProcessor {
    processTypeA(A item);
    processTypeB(B item);
    processTypeC(C item);
}

interface InputProcessor {
    processInput(ResultProcessor target);
}

class ConcreteInputProcessorA {
    processInput(ResultProcessor target) {
      A result = ...; // Do something
      target.processTypeA(result);
    }
}

class ConcreteInputProcessorB {
    processInput(ResultProcessor target) {
      B result = ...; // Do something
      target.processTypeB(result);
    }
}

class ConcreteInputProcessorC {
    processInput(ResultProcessor target) {
      C result = ...; // Do something
      target.processTypeC(result);
    }
}

更新：例如，您可以编写新编辑的代码：

public class AddOp implements IOperation{

    private int a;
    private int b;
    private int c;

    public AddOp(int a, int b){
        this.a = a;
        this.b = b;
    }

    @Override
    public void execute(Executor ex) {
        this.c = this.a + this.b;
        ex.executeAddOp(this);
    }
}

public class Executor {
    public void executeAddOp(AddOp op) {
        System.out.println("Executing an AndOp... " + op);
    }
}

Answer 2

在考虑了此处发布的一些建议后，我自己想到了另一种有趣的方法。

我不会接受它作为最终答案，因为我认为这对于那些花时间试图提供帮助的人是不公平的。但我还是想分享它。

public class SO {

    public static void main(String[] args){
        new SO().new Example().exec();
    }

    interface IResponse{
        //just a tagging interface
    }

    public class IntegerResponse implements IResponse{
        private int i;

        private IntegerResponse(int i) {
            this.i = i;
        }

        protected int getI() {
            return i;
        }

    }

    public class BooleanResponse implements IResponse{
        private boolean b;

        private BooleanResponse(boolean b) {
            this.b = b;
        }

        protected boolean isB() {
            return b;
        }

    }

    interface IOperation<X extends IResponse>{
        void execute();
        <X extends IResponse> X someMethod();
    }



    public class AddOp implements IOperation<IntegerResponse>{

        private int a;
        private int b;
        private int c;

        public AddOp(int a, int b){
            this.a = a;
            this.b = b;
        }

        @Override
        public void execute() {
            this.c = this.a + this.b;
        }

        @SuppressWarnings("unchecked")
        @Override
        public IntegerResponse someMethod() {
            return new IntegerResponse(this.c);
        }

    }

    public class AndOp implements IOperation<BooleanResponse>{

        private boolean a;
        private boolean b;
        private boolean c;

        public AndOp(boolean a, boolean b){
            this.a = a;
            this.b = b;
        }

        @Override
        public void execute() {
            this.c = this.a && this.b;
        }

        @SuppressWarnings("unchecked")
        @Override
        public BooleanResponse someMethod() {
            return new BooleanResponse(this.c);
        }

    }

    public class Example{
        public void exec(){
            IOperation<?> op = new AndOp(true,false);
            BooleanResponse resp = op.someMethod();
            System.out.println(resp.isB());
        }
    }
}

Answer 3

一种可能的方法是这样的：

private <T extends SomeCommonAncestor> T someMethod(InputParamObject i,
        Class<T> respClass)  {...}

对于返回的对象，您仍然需要一些通用接口/抽象类，并且您需要将实现/子类指定为方法参数的一部分。

希望这会有所帮助。

[编辑]

public interface IOperation{

       public <T extends ResultObject> T execute(Class<T> respClass);
}

public class AndOp implements IOperation{

    private boolean a;
    private boolean b;
    private boolean c;

    public AndOp(boolean a, boolean b){
        this.a = a;
        this.b = b;
    }    


   @Override
   public <T extends ResultObject> T execute(Class<T> respClass)
   {
       BoolWrap ret = new BoolWrap (a & b);
       return ret;
   }

}

class BoolWrap extends ResultObject {
 ...
}

class AndOpTest {
    public void testIt ()
    {
         AndOp op = new AndOp (false, true);
         BoolWrap result = op.execute (BoolWrap.class);
         //Profit?
    }
}