Java方法接受不同的功能介面型別--可能嗎？

首先，對于這個糟糕的標題，我感到很抱歉，但我發現用一句簡短的話來概括我的問題有些困難......

在我們的軟體中，有一些代碼讓我很不滿意。它是這樣的：

 @FunctionalInterface
    public interface OneArgCall<T, U, A> {
        T execute（U u, A arg）。
    }

    @FunctionalInterface; }
    public interface TwoArgCall<T, U, A, B> {
        T execute(U u, A arg, B arg2)。
    }

    public <T, U, A, B> T execCall(String x, Class<U> c, OneArgCall< T, U, A> call, A arg) {
        U u = doSomething（x, c）。
        try {
            return call.execute(u, arg);
        } catch (SomeException se) {
           handleSe(se)。
        } catch (SomeOtherException soe) {
           handleSoe(oe);
    }
    
    public <T, U, A, B> T execCall（String x, Class<P> c, TwoArgCall<T, U, A, B> call, A arg, B arg2）{
        U u = doSomething（x, c）。
        try {
            return call.execute(u, arg, arg2);
        } catch (SomeException se) {
           handleSe(se)。
        } catch (SomeOtherException soe) {
           handleSoe(oe);
    

也就是說，除了作為第三個引數傳遞的功能介面（當然還有該介面的引數串列），execCall方法是相同的。現在，我仍然可以接受這一點，但是這些方法的數量更多（想象一下ThreeArgCall、FourArgCall......）--這就是它變得有點令人無法忍受的地方。

那么，以所有DRY的名義：你將如何去清理這段代碼？我想象的是T execCall(String x, Class<U> c, SOMETHING, SOMETHING_ELSE)，其中SOMETHING可以是OneArgCall、TwoArgCall...的任何介面，SOMETHING_ELSE代表引數串列（？

這到底能不能做到？或者有什么其他的方法可以讓我重構這段代碼以減少重復性？

uj5u.com熱心網友回復：

你實際上不需要所有這些介面。 你不需要接收任何額外的方法引數。所有這些都可以由呼叫者使用 lambda 語法來處理。

這是你唯一需要的方法：

public <T, U> T execCall（String x, Class<U> c, Function<U, T> call） {
    U u = doSomething（x, c）。
    try {
        return call.apply(u);
    } catch (SomeException se) {
       handleSe(se)。
    } catch (SomeOtherException soe) {
       handleSoe(oe);

現在，假設你有一個需要多個引數的方法，你想使用execCall()，那該如何操作？

public Foo someMethodCall（bar bar, Arg1 a1, Arg2 a2） { .... }

Arg1 a1 = ...。
Arg2 a2 = ...。
String x = ...。
Bar b = execCall（x, Bar.class, (u) -> someMethodCall（u, a1, a2））。

使用lambda語法，你將你的3引數方法 "改編 "為1引數的Function介面。 這就是使用函式式編程中的 "部分應用 "概念。

uj5u.com熱心網友回復：

我可以想到一些受GOF設計模式啟發的方法來減少execCall中的重復，但代價是增加了復雜性，同時也給execCall的呼叫者增加了一些負擔。

1. 使用配接器或命令模式：

您可以洗掉重復的內容。

您可以通過讓 execCall 只接受一個介面并向 execCall 發送配接器來消除 execCall 的重復，配接器將包裹原始介面和引數并委托給它們。這意味著execCalls中的代碼會減少，但其他地方的代碼會增加。配接器將有一個統一的介面，這意味著引數必須被包裝在一個統一的基類中，而具體的配接器將不得不下移到他們知道的實際目標介面所需的引數型別。

與其將此解決方案視為配接器，你還可以將其視為實作命令模式。 與其讓每個客戶端只發送 execCall 的 2 或 3 個引數，不如讓他們發送一個完整的命令物件。這將是一些實作介面的類，包括一個抽象的執行函式。2個引數的客戶端將向execCall發送一個實作命令介面的物件，包括arg、arg2和call.execute(u, arg)一行。原始的execCall將執行commandObj.setU(u)，然后呼叫commandObj.execute()。這樣做的代價是讓呼叫者對call.execute的知識產生負擔

interface CallCommand<T,U> 
{
    T execute（） 。
    void setU（U u）。
}
class OneArgCallCommand<T,U,A> implements CallCommand<T,U> {
    A arg;
    U u;
    OneArgCall<T, U, A> 呼叫。
    public void setU( U u )  { this.u = u; }
    @Override
    public T execute（） {
        return call.execute(u, arg)。
    }
}
class TwoArgCallCommand<T,U,A,B> implements CallCommand<T,U> {
    A arg;
    B arg2;
    U u;
    TwoArgCall<T, U, A,B> 呼叫。
    public void setU( U u )  { this.u = u; }
    @Override
    public T execute（） {
        return call.execute(u, arg,arg2)。
    }
}


class Logic
{
public <T, U, A, B> T execCall(String x, Class<U> c, CallCommand<T, U> callCommand)  {
    U u = doSomething（x, c）。
    callCommand.setU(u)。
    try {
        return callCommand.execute()。
    } catch (SomeException se) {
       handleSe(se)。
    } catch (SomeOtherException soe) {
       handleSoe(oe);
    }
    return null;
}

2.使用模板方法模式

將execCall放在一個抽象的基類中。將execCall的大部分內容放在抽象類中，包括doSomething和tryCatch。把call.Execute這一行變成一個抽象方法，由每個派生類重寫。為2個引數的呼叫和3個引數的呼叫創建了execCall的派生版本，等等。同樣，不同的引數需要被打包在一個具體的類中，并有一個共同的抽象引數持有者父類，每個具體的execCall都需要下移到它知道自己需要的引數型別。這值得嗎？

3.

3.完全擺脫 execCall？

/**由AP生成的。請勿編輯。*/
public <T, U, A, B> T execCall（String x, Class<P> c, TwoArgCall<T, U, A, B> call, A arg, B arg2） {

    Supplier<T> s = () -> call.execute(u, arg, arg2);
    return ExecCallContainerTemplate.exec（x, c, s）。

public <T> T make（Class< T> type, String param） {
    構造器<T> c = type.getConstructor(String.class)。
    return c.newInstance（param）。

public <T> make(Function<String, T> factory, String param) {
    return factory.apply(param);
}

make(QuitMessage.class, " Going to sleep for the night")。

public class Calculator {
    public TwoArgCall<Double, Double, Double> addButton = (a, b) -> a   b;

  ....

    public void foo（）{
        double lhs = 5.5;
        double rhs = 3.3;
        calculatorTape.execCall（addButton, lhs, rhs）。
    }

public class Calculator {
    public TwoArgCall<Double, Double, Double> addButton = (a, b) -> a   b;

  ....

    public void foo（）{
        double lhs = 5.5;
        double rhs = 3.3;
        calculatorTape.execCall(() -> addButton.exec(lhs, rhs))。
    }
}