Java Scala：如何通过函数对象参数实现签名不同的通用流？

我是一名Java程序员，正在逐步学习Scala编程

我定义了一个类似的函数（这可能是习惯用法上的错误，我不知道…）：

因此，函数接收3个参数，按顺序处理前两个参数，获取处理结果，并根据SpecificClogicFunction将其沿着第三个参数传递给

SomeToBereplaceDac

现在我想写一个类似的函数，因为前两个函数调用都存在，错误逻辑是相同的，唯一的区别是，
someToBeReplacedAccordingToSpecificLogicFunction
现在是
aReplacementLogicFunction

如果这两个函数具有相同的签名，我想这不会是一个问题，但是，
aReplacementLogicFunction
具有不同的参数，更具体地说，还有两个参数。您可能会说，我可以传入
Option
参数，在第一种情况下，这两个
Option
s是
None
s，这样我就可以使我的两个函数具有相同的签名，因此：

def someToBeReplacedAccordingToSpecificLogicFunction(result1: Int, result2: Int, param3: String, unused1:Option[String] = None, unused2:Option[String] = None)

def aReplacementLogicFunction(result1: Int, result2: Int, param3: String, used1:Option[String], used2:Option[String])

但是，存在第三个流，其中第一个函数的不存在参数属于不同的类型，例如MyClass，例如：

def anotherReplacementLogicFunction(result1: Int, result2: Int, param3: String, used1: MyClass, used2: MyClass)

那么，问题是，我将如何将这些函数泛化，以传递给某个将接收函数作为参数的重构泛型算法函数。有没有一种方法可以定义如下内容：

def refactoredOutCoreLogic(param1: String, param1: String, param3: String, polimorphicFunction: SignatureUnknown)

void refactoredOutCoreLogic(String param1, String param2, String param3, ResultKeeperRunnable polimorphicLogic) {
    // error handling logic removed for brevity
    int result1 = someMethod(param1);
    int result2 = someOtherMethod(param2);
    polymorphicLogic.setParam1(result1);
    polymorphicLogic.setParam2(result2);
    polymorphicLogic.run()
    ...

}

要在Java中回答我自己的问题，请执行以下操作：

我在Java中解决这个问题的方法是定义一个类层次结构，类似于：

abstract class ResultKeeperRunnable implements Runnable {
    protected int param1, param2;
    void setParam1(...) {...}
    void setParam2(...) {...}
}

class SomeToBeReplacedAccordingToSpecificLogicFunctionClass extends ResultKeeperRunnable  {
    String param3;
    // ctor receiving all params omitted for brevity 
    void run() {
      // do specific Logic
    }
}

class AReplacementLogicFunctionClass extends ResultKeeperRunnable {
    String param3, param4, param5;
    // ctor receiving all params omitted for brevity 
    void run() {
      // do specific Logic
    }
}

class AnotherReplacementLogicFunctionClass extends ResultKeeperRunnable {
    String param3;
    MyClass param4, param5;
    // ctor receiving all params omitted for brevity 
    void run() {
      // do specific Logic
    }
}

最后，分解出的核心逻辑方法如下：

def refactoredOutCoreLogic(param1: String, param1: String, param3: String, polimorphicFunction: SignatureUnknown)

void refactoredOutCoreLogic(String param1, String param2, String param3, ResultKeeperRunnable polimorphicLogic) {
    // error handling logic removed for brevity
    int result1 = someMethod(param1);
    int result2 = someOtherMethod(param2);
    polymorphicLogic.setParam1(result1);
    polymorphicLogic.setParam2(result2);
    polymorphicLogic.run()
    ...

}

Scala解决方案是否不再是上述Java解决方案在语法上的不同克隆？似乎应该有一个更优雅的解决方案。
您有一个函数，它接受
result1
、
result2
，以及一系列其他参数

您需要一个只接受
result1
和
result2
的函数

为此，请使用。编写如下所示的可替换函数，在末尾添加第二组括号，其中包含公共参数：

def aReplacementLogicFunction(param3: String, used1:Option[String], used2:Option[String])(result1: Int, result2: Int)

然后将部分应用的函数传递到常用函数中，如下所示：

someGenericAlgorithm(param1, param2, aReplacementLogicFunction(param3, used1, used2))

就通用算法而言，它完全不知道额外的参数。这些都是在调用函数之前应用的。
谢谢@Karl这是一个漂亮而优雅的解决方案！