我们如何在Lambda表达式中实现它？

Question

首先我们必须在lambda表达式的其他文件或同一个文件中声明接口。但是如果我们能在方法声明中做到这一点会更容易。那么反正呢？

 public class LambdaAppJava8 {
 public int fonk(
     int a, 
     int b, 
     interface MyInterface{
          public int call(int a, int b);
     } anonim
 ) {
    return anonim.call(a, b);
 }

 public static void main(String[] args) {
    LambdaAppJava8 app = new LambdaAppJava8();
    System.out.println(app.fonk(1, 3, (c, d) -> c + d));
 }
}

Answer 1

没有办法在方法声明中声明一个接口，但是你可以使它成为一个足够接近的嵌套类型。

public class LambdaAppJava8 {
    private interface MyInterface {
        public int call(int a, int b);
    }
    public int fonk(int a, int b, MyInterface anonim) {
        return anonim.call(a, b);
    }
    public static void main(String[] args) {
        LambdaAppJava8 app = new LambdaAppJava8();
        System.out.println(app.fonk(1, 3, (c, d) -> c + d));
    }
}

似乎还存在对匿名interface含义的误解。 您可以在方法中声明匿名类，但这些类不是“在运行中”声明的; 它们仍然是在编译时创建的类型，它们有自己的类文件，它不小于顶级类型，实际上，它是相反的。 这些类型具有比顶级类型更大的类文件，因为它们包含关于定义它们的周围上下文的元信息。

如果有办法在方法的参数列表中声明一个interface那就不会改变; 它比在其他地方宣布它更有效率。 但是它需要特殊的作用域规则异常，因为在正常的作用域规则下，你不能调用一个方法，该方法需要方法本地类型的参数，因为调用者不会知道该类型。

---

但请注意，上面的示例实际上是您想要实现的。 您还可以将MyInterface的声明MyInterface为public ，其他类可以使用lambda表达式调用该方法，例如使用用例app.fonk(1, 3, (c, d) -> c + d) 而无需导入 MyInterface 。 这是你的问题似乎是什么，调用者不必处理专门为fonk参数定义的interface ，编译器就是这样。

Answer 2

没有办法在java中执行此操作，您无法在方法减速中声明匿名类/接口。

如果您正在寻找针对该特定方案的解决方案，那么我建议：

public int fonk(
     int a, 
     int b, 
     BiFunction<Integer, Integer, Integer> anonim
 ) {
    return anonim.apply(a, b);
 }

根据： BiFunction

Answer 3

你可以这样做

import java.util.function.BiFunction;


public class LambdaAppJava8 {
    public static int fonk(int a, int b,int c,
             BiFunction<Integer,Integer,Integer> func
         ) {
            return func.apply(func.apply(a, b),c);
         }
    public static void main(String[] arg){
        int sum = fonk(1,2,3,(x,y)->x+y);
        int product = fonk(1,2,3,(x,y)->x*y);
        System.out.println(sum);
        System.out.println(product);
    }
}