将参数传递给方法引用

Question

给定此方法：

private static Integer getVal(Integer a, Integer b){
   return a + b;
}

可以称为lambda：

a -> getVal(1, 2)

无论如何，有没有将其转换为方法引用，例如：

Class::getVal

谢谢

Answer 1

好吧，如果你是路过常数的方法调用，您可以创建一个调用原始方法的另一种方法：

private static Integer getVal (Integer a) {
    return getVal(1,2);
}

那么你可以使用方法引用了第二种方法。

例如，你可以改变

a -> getVal(1, 2)

至

ClassName::getVal

这就是说，它并没有太大的意义。

PS，目前还不清楚什么目的a在lambda表达式，因为你忽视它。

一般来说，如果它所需功能接口的单个​​方法的签名相匹配可以传递给定的方法的方法的参考。

例：

public static Integer apply (BinaryOperator<Integer> op, Integer a, Integer b)
{
    return op.apply(a,b);
}

现在您可以致电：

apply(ClassName::getVal)

与原来的方法。

Answer 2

这是一个例子。

interface Operator {
    int operate(int a, int b);
}

class Calc {
    public static int add(int a, int b) {
        return a + b;
    }
}

class Main {    
    public static void main(String[] args) {
        // using method reference
        int result = operate(1, 2, Calc::add);
        // using lambda
        int result = operate(1, 2, (a, b) -> Calc.add(a, b));
    }

    static int operate(int a, int b, Operator operator) {
        return operator.operate(a, b);
    }
}

您需要一个功能接口来使用方法引用（在本示例中为Operator ）。 而且，您还需要一种方法，该方法接受功能接口的实例作为其解析器（在此示例中， operate(int a, int b, Operator operator ）。

更新

如果需要对象包装，只需将operate方法更改为

static int operate(ObjectWrapper wrapper, Operator operator) {
    return operator.operate(wrapper.getA(), wrapper.getB());
}

然后调用operate方法：

int result = operate(wrapper, Calc::add);

Answer 3

getVal（）仅在期望适用类型的功能接口（例如BiFunction或IntBinaryOperator ）或自定义功能接口（如zhh的答案 ）的地方可用作方法引用。

例：

    public static void main(String[] args) {
        Integer result1 = calculate(1, 2, Second::getVal);
        Integer result2 = calculateAsInt(1, 2, Second::getVal);
    }

    private static Integer getVal(Integer a, Integer b){
        return a + b;
    }

    private static Integer calculate(Integer a, Integer b, BinaryOperator<Integer> operator) {
        return operator.apply(a, b);
    }

    private static int calculateAsInt(int a, Integer b, IntBinaryOperator operator) {
        return operator.applyAsInt(a, b);
    }