如何在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。

不是返回一個值（即Object），而是返回void並將參數傳遞給要將結果放入的目標對象。

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

一種可能的方法是這樣的：

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? 
    } 
} 

Answer 3

我自己來到了另一個有趣的方法，考慮貼在這裏的一些建議之後。

我不會接受它作爲最終答案，因爲我認爲這對於那些花時間試圖幫助的人來說並不公平。但我想分享它。

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()); 
     } 
    } 
}