将通配符与泛型方法一起使用

Question

想得到一些建议

我的班级结构是这样的

public abstract class Base {}
public class Derived1 extends Base {}
public class Derived2 extends Base {}

public class ServiceClass {
    public String method1(Derived1 derived1) {
        return "derived1";
    }
    public String method2(Derived2 derived2) {
        return "derived2";
    }
}

在我的主代码（MainProg）中，我试图使用相同的函数来引用服务类中的2个方法，并看到注释中的编译错误

public class MainProg {
    public static void main(String[] args) {
        ServiceClass serviceClass = new ServiceClass();

        //Incompatible types: Base is not convertible to Derived1
        Function<? extends Base,String> function1 = serviceClass::method1; 

        //Incompatible types: Object is not convertible to Derived1            
        Function<?,String> function2 = serviceClass::method1;
            
        //Incompatible types: Base is not convertible to Derived2
        Function<? super Base,String> function3 = serviceClass::method2;
    }
}

有没有办法声明我的函数对象，以便可以使用相同的函数对象来引用采用不同类型参数的方法？

Answer 1

您可以将模式匹配用于开关表达式，它仍处于预览阶段，但将很快在即将于2022年9月发布的Java19中完成。

public static class ServiceClass {
    public static String method(Base base) {
        return switch (base) {
            case Derived1 d1 -> "Derived1";
            case Derived2 d2 -> "Derived2";
            default          -> "Unknown subtype";
        };
    }
}

main（）

public static void main(String[] args) {
    Function<? super Base,String> func = ServiceClass::method;

    System.out.println(func.apply(new Derived1()));
    System.out.println(func.apply(new Derived2()));        
}

输出：

Derived1
Derived2

Answer 2

//Incompatible types: Base is not convertible to Derived1
Function<? extends Base,String> function1 = serviceClass::method1; 

这是一种我不完全理解的奇怪的类型推断。这是推断函数

你可以这样修理它。演员阵容安全：

Function<? extends Base,String> function1 = (Function<Derived1, String>) serviceClass::method1;

或者这个：

Function<Derived1, String> tmp = serviceClass::method1;
Function<? extends Base,String> function1 = tmp;

值得注意的是，您永远不能调用此函数（除非使用null），因为您已经放弃了它所期望的参数类型的知识<代码>？extends Base是扩展Base的东西（即Derived1或Derived2），但我们不知道是哪个。

//Incompatible types: Object is not convertible to Derived1            
Function<?,String> function2 = serviceClass::method1;

与第一个问题相同，只是它推断的是对象而不是基础。

//Incompatible types: Base is not convertible to Derived2
Function<? super Base,String> function3 = serviceClass::method2;

Derived1或Derived2不是Base的超类。它们是子类。只有Object是Base的超类。方法2不期望对象。

Answer 3

是的，通过使用中间变量：

    Function<Derived1, String> function1 = serviceClass::method1;
    Function<Derived2, String> function2 = serviceClass::method2;        
    Function<? extends Base, String> function = condition ? function1 : function2;

也就是说，您将无法调用函数，因为您不知道是传递Derived1还是Derived2，或者正如编译器所说：

    function.apply(new Derived2()); 
    // error: The method apply(capture#1-of ? extends Base) in the type Function<capture#1-of ? extends Base,String> is not applicable for the arguments (Derived2)

但是，您可以使用泛型对参数类型进行抽象：

<T extends Base> invokeSafely(Function<T, String> function, T argument) {
    function.apply(argument);
}

这样你就可以写

invokeSafely(serviceClass::method1, new Derived1());
invokeSafely(serviceClass::method2, new Derived2());

但不是

invokeSafely(function, new Derived1()); // same error as before