java - 实现 MapChangeListener 的 onChanged - 为什么这个 lambda

Question

在我的 JavaFX 中，我试图拥有一个 ObservableMap<String, String>和一个 MapChangeListener监听键和值的变化(添加/删除键或相应的值)然后执行其工作。

为了使监听器有效，实现的方法是:

void onChanged(MapChangeListener.Change<? extends K,? extends V> change)

我首先使用 lambda 表达式执行的操作不会产生任何错误:

map.addListener((MapChangeListener.Change<? extends String, ? extends String> change) -> {
    //code here to implement onChange method
}

这是我发现的，仍然没有产生任何错误:

map.addListener((MapChangeListener<String, String>) change -> {
    //code here to implement onChange method
}

注意这两个不同示例中圆括号的位置。第二个在我看来是类型转换，但我真的不明白为什么第二个选项有效。
谁能给我解释一下，好吗？

P.S.:实际上，我遇到这个是因为我正在处理一个
ObservableMap<String, List<String>> ,
那是一个多图，上面两个中的第一个“方式”不起作用(经过正确的调整)。 /EDIT: 我用第一种“方式”再次尝试，实际上它确实有效，我没有注意到END EDIT/ 的代码有错误。然后我尝试了第二个选项，它确实有效，我很茫然。然后我用一张简单的 map 发现了同样的“行为”<String, String>并且出现了这个问题。

Answer 1

这两个是等价的。第一个，您正在定义 lambda 表达式的参数 - 请注意，您的括号涵盖了整个更改参数。这允许编译器知道要匹配哪个重载。

第二个只是类型转换。您是在告诉编译器将哪种方法签名与此 lambda 匹配。 (MapChangeListener<String, String>)将整个 lambda 表达式转换为 MapChangeListener , 所以编译器知道它确实是 addListener(MapChangeListener) .由于您已经定义了 MapChangeListener 定义的单个参数，编译器也不会提示它是错误的。

编辑

现在我有更多的时间，我会举一些具体的例子来帮助你更深入地理解。

public class Foo {
    public final void bar(IntfA a) {}
    public final void bar(IntfB b) {}
    public final void bar(IntfC c) {}
}

@FunctionalInterface
public interface IntfA {
    void doSomething(Double a);
}

@FunctionalInterface
public interface IntfB {
    void doSomething(Integer a);
}

@FunctionalInterface
public interface IntfC {
    void doSomething(Double a);
}

public class Test {
    public static void main(String[] args)
    {
        Foo foo = new Foo();

        foo.bar(a -> {}); // Ambiguous
        foo.bar((Integer a) -> {}); // Okay, this is IntfB
        foo.bar((Double a) -> {}); // Ambiguous between IntfA and IntfC
        foo.bar((IntfC) a -> {}); // No longer ambiguous since you specified that it's IntfC
        foo.bar((IntfC) (a, b) -> {}); // Method signature does not match IntfC
    }
}

编辑2

看来您在这里需要更多帮助。

当你定义一个方法时bar(IntfA) , 你期待一个 IntfA 的对象，无论是否IntfA是接口(interface)类型还是类类型。

然后，lambda 表达式只是编译时方便的语法。当我写 foo.bar((Integer a) -> {}) ，编译器最终会将其转换为等同于此的 Java 字节码(在 .class 文件中):

foo.bar(new IntfB() {
    public void doSomething(Integer a) {
    }
});

这种等价就是我们所说的 Anonymous Class .

使用 lambda 最大且可能唯一的区别是，它使您的代码更短。有时它使您的代码更具可读性，有时它使您的代码可读性降低。

由于 lambda 减少了您需要输入的内容的数量，因此当存在像示例中那样的重载方法时，很容易使 lambda 表达式对编译器产生歧义。请记住，编译器需要先找出哪个重载，然后它会帮助您为您实例化对象。

当你写 foo.bar((Double a) -> {}) ，编译会注意到您有一个 lambda 表达式，它接受一个 Double参数，不返回任何内容。然后它将查看 bar() 的三个重载。 .它注意到 bar(IntfA)和 bar(IntfC)接受一个功能接口(interface)，两个接口(interface)的方法都接受一个 Double参数，不返回任何内容。此时，编译器不确定是否应该生成相当于哪两组代码的字节码:

选择 1:

foo.bar(new IntfA() {
    public void doSomething(Double a) {
    }
});

选择 2:

foo.bar(new IntfC() {
    public void doSomething(Double a) {
    }
});

如果你写foo.bar((IntfC) a -> {}) ，您已经在向编译器暗示您希望它匹配 foo.bar(IntfC)重载。编译器发现您有一个未知类型的参数，但由于您已经告诉它匹配 IntfC , 它将假定参数为 Double .

现在到最后一部分，调用 foo.bar(IntfA)不会自动调用 doSomething(Double a) IntfA 指定的方法.在我的示例中 bar()方法什么都不做，但通常人们会写一些有用的东西。

再举个例子:

public final void bar(IntfB obj) {
    if (obj == null)
        System.out.println("I was waiting for an IntfB object but I got nothing!");
    else
        obj.doSomething(100);
}

foo.bar((Integer a) -> {
    System.out.println("I got " + a + " marks for my exam!");
});

这会导致“我考试得了 100 分!”打印在控制台上。