泛型方法中使用通配符：如何用同一函数对象引用不同参数类型的方法？

首先，我们得先搞清楚你遇到编译错误的核心原因：Java的函数式接口类型检查严格遵循逆变/协变规则，你的method1和method2分别只接受Derived1和Derived2类型的参数，你尝试的几种Function通配符声明都不符合类型安全要求：

• Function<? extends Base,String>：这个类型表示函数可以接受任意Base的子类作为参数，但method1只能处理Derived1，如果允许赋值，后续调用时传入Derived2会导致运行时错误，因此编译器直接拒绝。
• Function<?,String>：通配符?是未知类型，编译器无法验证传入的参数是否匹配Derived1/Derived2，所以报错类型不兼容。
• Function<? super Base,String>：这个类型要求函数能接受Base或其父类作为参数，但method2只能处理Derived2（Base的子类），无法兼容Base类型的输入，自然类型不匹配。

方案1：非类型安全的通配符方式（不推荐） #

如果你只是想让同一个变量能赋值两个方法引用，可以用Function<?, String>，但调用时必须手动保证传入参数的类型正确，否则会抛出ClassCastException：

public class MainProg {
    public static void main(String[] args) {
        ServiceClass serviceClass = new ServiceClass();
        Function<?, String> func = serviceClass::method1;
        // 可以切换赋值为method2的引用
        func = serviceClass::method2;
        
        // 必须传入对应类型的参数，否则运行时出错
        String res1 = func.apply(new Derived2()); // 正常返回"derived2"
        // String res2 = func.apply(new Derived1()); // 当func指向method2时，会抛出ClassCastException
    }
}

这种方式简单但完全依赖开发者的手动判断，编译器无法提供类型检查保障，不建议在生产代码中使用。

方案2：类型安全的访问者模式（推荐） #

如果希望类型安全地处理不同的Base子类，同时复用ServiceClass中的逻辑，访问者模式是Java中处理这种子类多态场景的经典方案：

步骤1：定义访问者接口 #

@FunctionalInterface
interface BaseVisitor<R> {
    R visit(Derived1 d1);
    R visit(Derived2 d2);
}

步骤2：修改Base类添加accept方法 #

public abstract class Base {
    public abstract <R> R accept(BaseVisitor<R> visitor);
}

步骤3：在子类中实现accept方法 #

public class Derived1 extends Base {
    @Override
    public <R> R accept(BaseVisitor<R> visitor) {
        return visitor.visit(this);
    }
}

public class Derived2 extends Base {
    @Override
    public <R> R accept(BaseVisitor<R> visitor) {
        return visitor.visit(this);
    }
}

步骤4：让ServiceClass实现访问者接口 #

public class ServiceClass implements BaseVisitor<String> {
    @Override
    public String visit(Derived1 derived1) {
        return "derived1";
    }

    @Override
    public String visit(Derived2 derived2) {
        return "derived2";
    }
}

步骤5：在主类中使用 #

public class MainProg {
    public static void main(String[] args) {
        ServiceClass serviceClass = new ServiceClass();
        Base d1 = new Derived1();
        Base d2 = new Derived2();
        
        // 类型安全地调用对应子类的处理逻辑
        String result1 = d1.accept(serviceClass); // 返回"derived1"
        String result2 = d2.accept(serviceClass); // 返回"derived2"
    }
}

这种方式完全符合Java的类型系统规则，编译器会帮你做严格的类型检查，不会出现运行时类型转换错误，同时完美实现了“用同一类对象处理不同子类”的需求。

内容的提问来源于stack exchange，提问作者Raman