我在处理一些旧代码时偶然发现了一个问题，用 lambda 表达式或方法引用替换了几个匿名类。这个问题有点难以用语言来解释，但我会尽力而为，我还在下面添加了一个简短的例子来说明我的问题。
我的示例包括...
一个功能接口GenericListener，它接受一个类型参数 V并有一个方法“genericCallback(V genericValue)”。
一个类CallbackProducer，它接受一个类型参数 T。这个类还有一个方法来添加一个 Integer 类型的 GenericListener。
一个Main类，它创建 CallbackProducers 并向它们添加 GenericListeners。
当我从 Main 的构造函数运行 CallbackProducer 的 addIntegerListener 方法时，每当我避免指定 CallbackProducer 的 T 的类型时，我都会收到编译器错误：“不兼容的类型” 。
addIntegerListener 方法只使用了 GenericListener 的 V。据我所知，它并没有以任何方式使用 CallbackProducer 的 T。
我在 Main 的构造函数中对 addIntegerListener + 注释进行了多次调用，其中 3 次导致编译器错误。但据我所知（根据 IntelliJ），所有这些都应该是合法的。如果您注释掉对 addIntegerListener 的 3 个第一次调用，则应用程序将编译并运行得很好。
此外，如果 CallbackProducer 不使用泛型，并且我们完全删除了类型参数 T，则对 addIntegerListener 的 3 次第一次调用将编译。
这种行为有原因吗？我是不是误解了什么，或者这是java编译器中的一个弱点或错误？（我目前正在使用 java 1.8_51）
提前感谢您的澄清！
import javax.swing.*;
public class Main {
public static void main(final String[] args) {
SwingUtilities.invokeLater(Main::new);
}
public Main() {
// Compiler error, type of CallbackProducer's "T" not specified
CallbackProducer producer1 = new CallbackProducer();
producer1.addIntegerListener(this::integerReceived);
// Compiler error, no diamond brackets for CallbackProducer
new CallbackProducer().addIntegerListener(this::integerReceived);
// Also compiler error for lambdas with no diamond brackets on CallbackProducer
new CallbackProducer().addIntegerListener(intValue -> integerReceived(intValue));
// Works because a (any) type for CallbackProducer's "T" is specified
CallbackProducer<Object> producer2 = new CallbackProducer<>();
producer2.addIntegerListener(this::integerReceived);
// Works because of the diamond brackets
new CallbackProducer<>().addIntegerListener(this::integerReceived);
// Lambda also works with diamond brackets
new CallbackProducer<>().addIntegerListener(intValue -> integerReceived(intValue));
// This variant also works without specifying CallbackProducer's "T"
// ... but it is a workaround I'd prefer to avoid if possible :-P
GenericListener<Integer> integerListener = this::integerReceived;
new CallbackProducer().addIntegerListener(integerListener);
}
private void integerReceived(Integer intValue) {
System.out.println("Integer callback received: " + intValue);
}
// A callback producer taking generic listeners
// Has a type parameter "T" which is completely unrelated to
// GenericListener's "V" and not used for anything in this
// example really, except help provoking the compiler error
public class CallbackProducer<T> {
// Adds a listener which specifically takes an Integer type as argument
public void addIntegerListener(GenericListener<Integer> integerListener) {
// Just a dummy callback to receive some output
integerListener.genericCallback(100);
}
}
// A simple, generic listener interface that can take a value of any type
// Has a type parameter "V" which is used to specify the value type of the callback
// "V" is completely unrelated to CallbackProducer's "T"
@FunctionalInterface
public interface GenericListener<V> {
void genericCallback(V genericValue);
}
}
这是一个缩短的版本，没有所有的评论混乱，只有两次调用“addIntegerListener”，其中一次导致编译器错误。
import javax.swing.*;
public class Main {
public static void main(final String[] args) {
SwingUtilities.invokeLater(Main::new);
}
public Main() {
CallbackProducer producer1 = new CallbackProducer();
producer1.addIntegerListener(this::integerReceived); // Compiler error
CallbackProducer<Object> producer2 = new CallbackProducer<>();
producer2.addIntegerListener(this::integerReceived); // Compiles OK
}
private void integerReceived(Integer intValue) {
System.out.println("Integer callback received: " + intValue);
}
public class CallbackProducer<T> {
public void addIntegerListener(GenericListener<Integer> integerListener) {
integerListener.genericCallback(100);
}
}
@FunctionalInterface
public interface GenericListener<V> {
void genericCallback(V genericValue);
}
}