Java 8 Lambda表达式-方法重载

我在学Lambda的表达方式

接口MathOperator

对int和float类型重载了operate（），我确信这应该可以使用Lambda表达式来实现，但似乎还不太清楚这里的问题是什么：

public static void main(String[] args) {
    LambdaLearning lb = new LambdaLearning();

    MathOperartor add = (a , b )->  a + b;  // error: The target type of this expression must be a functional interface
    MathOperartor sub = (a , b) -> a - b;   // same error
    MathOperartor mul = (a , b) -> a * b;   //  ''
    MathOperartor div = (a , b) -> a / b;   //  ''

    System.out.println(lb.operate(10, 15, add));
    System.out.println(lb.operate(10.5f, 15.5f, sub));
    System.out.println(lb.operate(10, 15, mul));
    System.out.println(lb.operate(10, 15, div));

}

interface MathOperartor{
    public Object operate(int a, int b);
    public Object operate(float a, float b);
}

private Object operate(int a, int b, MathOperartor math){
    return math.operate(a,b);
}
private Object operate(float a, float b, MathOperartor math){
    return math.operate(a,b);
}

请让我知道我做错了什么，并建议解决方法

更新：

@FunctionalInterface
public interface SimpleFuncInterface {
  public void doWork();
}

好的，所以我理解了功能接口的概念，我的问题也是关于在上面的代码中实现我想做的事情，我找到了两种方法

谢谢大家宝贵的回答

A必须是SAM接口：

函数接口只有一个抽象方法。因为默认方法有一个实现，所以它们不是抽象的。如果接口声明一个抽象方法覆盖java.lang.Object的一个公共方法，则该方法也不计入接口的抽象方法计数，因为接口的任何实现都将具有来自java.lang.Object或其他地方的实现

您的接口声明了2个抽象方法，lambda表达式不知道该方法的去向，lambda表达式是该接口的一个实例，这意味着它必须实现接口中声明的所有抽象方法。但是您可以添加默认方法来解决这种情况下的问题，例如：

interface MathOperartor{
  //it also can be removed, since a int can cast to a float automatically
  default Object operate(int a, int b){
     return operate((float)a, (float)b);
  }
  public Object operate(float a, float b);
}

@FunctionalInterface
public interface MathOperator<T> {
     T operate(T a,T b);
}

public class MathOperations {
    public static void main(String[] args) {

        MathOperator<Integer> add = (a, b) -> a + b;
        MathOperator<Integer> sub = (a, b) -> a - b;

        System.out.println(add.operate(1, 2));
        System.out.println(sub.operate(2, 1));

    }

}

---

函数接口可以有一个抽象方法，但不能超过这个方法。

基本上，您的接口只能有一个方法。你不能让它们超载

---

一般来说，其他答案是正确的，

@functional接口

除了在

对象

中声明的方法外，还有一个抽象方法。这仍然是合法的：

    @FunctionalInterface
    static interface Testable {

       public abstract String toString();

       public abstract void test();
    }

---

函数接口中lambda的目标，也称为SAM（单一抽象方法）接口。 以下是如何运行示例：

interface MathOperartor{
  //it also can be removed, since a int can cast to a float automatically
  default Object operate(int a, int b){
     return operate((float)a, (float)b);
  }
  public Object operate(float a, float b);
}

@FunctionalInterface
public interface MathOperator<T> {
     T operate(T a,T b);
}

public class MathOperations {
    public static void main(String[] args) {

        MathOperator<Integer> add = (a, b) -> a + b;
        MathOperator<Integer> sub = (a, b) -> a - b;

        System.out.println(add.operate(1, 2));
        System.out.println(sub.operate(2, 1));

    }

}

@functioninterface
公共接口运算符{
T操作（T a，T b）；
}
公共类数学运算{
公共静态void main（字符串[]args）{
数学运算符add=（a，b）->a+b；
数学算子sub=（a，b）->a-b；
系统输出打印LN（添加操作（1,2））；
系统输出打印LN（子操作（2，1））；
}
}

---

希望它能帮助您

一种信息性注释类型，用于指示接口类型声明是功能性接口

函数接口只有一个抽象方法。因为默认方法有一个实现，所以它们不是抽象的。如果接口声明一个抽象方法覆盖java.lang.Object的一个公共方法，则该方法也不计入接口的抽象方法计数，因为接口的任何实现都将具有来自java.lang.Object或其他地方的实现

示例：

@FunctionalInterface
public interface SimpleFuncInterface {
  public void doWork();
}

但是一个接口可以有一个抽象方法，但是可以有任意数量的默认方法，并且该接口仍然可以称为函数接口

示例：

@FunctionalInterface
public interface SimpleFuncInterface {
  public void doWork();
}

因此，您的代码将转换为：

interface MathOperartor {

    default Object operate(int a, int b) {
        return operate((float) a, (float) b);
    }

    public Object operate(float a, float b);

}

可以使用lambda表达式、方法引用或构造函数引用创建函数接口的实例

---

但是，无论接口声明中是否存在FunctionInterface注释，编译器都会将满足函数接口定义的任何接口视为函数接口。

如果该接口中只需要一个抽象方法，请查找函数接口。“此表达式的目标类型必须是函数接口“=>嗯。。。类型

MathOperator

不是一个。可能的加宽类型转换重复可以由JVM自动完成，您不需要两种操作方法。一个函数接口可以有一个抽象方法。谢谢！这就解释了我的疑问并解决了代码中的错误。@Balu一点也不。这是我的荣幸。