0

我正在阅读本教程中的 Java 功能接口

这是困扰我的具体代码：

public interface FunctionalInterfaceTest{
void display();
}
//Test class to implement above interface
public class FunctionInterfaceTestImpl {
      public static void main(String[] args){
     //Old way using anonymous inner class
     FunctionalInterfaceTest fit = new FunctionalInterfaceTest(){
        public void display(){
           System.out.println("Display from old way");
        }};
     fit.display();//outputs: Display from old way
     //Using lambda expression
     FunctionalInterfaceTest newWay = () -> {System.out.println("Display from new Lambda Expression");}
        newWay.display();//outputs : Display from new Lambda Expression
     }
}

我不明白。有一个名为display(). 它不做任何事情，也从未定义过。是的，我知道当您在功能接口中调用单个方法时，它会执行在其中创建的 lambda 表达式中的代码。

但这是我的问题；如果所有函数式接口本质上都只是运行 lambda 表达式，那么为什么不节省我们命名单个方法的时间，并使其永久化exe()呢？如果它几乎没有添加任何内容，那么提供功能接口语法和自定义的意义何在。对我来说更好的语法是：

@FunctionalInterface MyInterface

MyInterface mine = () -> {System.out.print("Mine!!")}
mine.exe();

这更标准，更短，更容易理解。

这是一个绝妙的主意还是我错过了什么？

4

1 回答 1

2

有一个名为 display() 的函数有什么意义。它不做任何事情，也从未定义过。

它本质上仍然是一个接口，并且它仍然受制于与不使用 lambda 时接口相同的不稳定规则。

该display方法可以以完全相同的方式在具体类上定义......

public class Concrete implements FunctionalInterfaceTest {

    @Override
    public void display() {
        System.out.println("Displayed!  W00t!");
    }
}

...我们会做同样多的工作：我们有一个只产生副作用的界面。这是不可取的。

当您想要对对象或原语实际执行纯操作时，它的真正威力就出现了，但您不想定义具体的类只是为了指定这些操作实际上是什么。

假设我们想要一个函数式接口来给我们两个Numbers 的区别。

@FunctionalInterface
public interface NumberAdder<T extends Number>  {
    T result (T firstValue, T secondValue);
}

然后我可以以这种方式使用它：

NumberAdder<Integer> numberAdder = (x, y) -> x + y;
NumberAdder<Long> longAdder = (x, y) -> x + y;
// From (x, y) -> x.add(y);, the below is shortened to a method reference
NumberAdder<BigInteger> bigIntAdder = BigInteger::add;

总的来说，子类化的语法糖——无论是否匿名——都必须在接口中发生。相反，我可以定义一次合同，并在我需要的任何场景/上下文中定义行为。

System.out.println(numberAdder.result(10, 20));
System.out.println(longAdder.result(172893791273L, 979789123L));
System.out.println(bigIntAdder.result(BigInteger.valueOf(172917298179821L), BigInteger.valueOf(17232891L)));

定义行为仍然是您的责任。你可以很容易地写这个：

NumberAdder<BigInteger> bigIntAdder2 = BigInteger::divide;

...而且界面仍然很好。在实际实施时，您需要小心不要滥用您的预期用途。

不要将 lambdas 视为它们不是的任何东西。总的来说，您正在用 lambda 表达式替换匿名类。如果您想看中它，我们非常欢迎您，但不要假设每个功能接口都遵循它们之间的相同约定。

于 2015-11-09T06:45:52.910 回答