Java泛型方法如何限定参数为含特定方法名的任意类型（非继承）？

Java作为静态类型语言，直接通过泛型的类型参数约束（比如<T extends SomeInterface>）确实做不到只靠方法名来约束类型——毕竟这种约束要求类型必须继承/实现某个类或接口。但我们有两种实用的方案绕开这个限制，不用强制类型继承：

方案一：利用反射（简单直接，但编译期不安全） #

反射可以让我们在运行时检查并调用对象的方法，完全不依赖编译期的类型约束。比如我们要调用任意类型的doSomething()方法：

import java.lang.reflect.Method;

public class GenericMethodDemo {
    public static <T> void callDoSomething(T obj) {
        try {
            // 获取无参的doSomething方法
            Method method = obj.getClass().getMethod("doSomething");
            // 调用方法
            method.invoke(obj);
        } catch (Exception e) {
            // 处理找不到方法、调用失败等异常
            e.printStackTrace();
        }
    }

    // 测试用的两个无关类，都有doSomething方法
    static class Foo {
        public void doSomething() {
            System.out.println("Foo is doing something");
        }
    }

    static class Bar {
        public void doSomething() {
            System.out.println("Bar is doing something");
        }
    }

    public static void main(String[] args) {
        callDoSomething(new Foo());
        callDoSomething(new Bar());
    }
}

这种方式的优缺点很明显：

• 优点：完全不用修改现有类的结构，适配任意有目标方法的类型
• 缺点：编译期无法检查目标对象是否真的有对应方法，只有运行时才会报错；反射调用性能比直接调用差；需要手动处理各种异常（找不到方法、权限问题等）

方案二：方法引用+函数式接口（编译期安全，更优雅） #

Java 8引入的方法引用和函数式接口可以让我们在编译期就确保方法存在，同时不用强制类型实现接口。核心思路是：定义一个匹配目标方法签名的函数式接口，让调用者传入方法引用而非直接传入对象。

比如针对无参无返回值的doSomething()：
Java内置的Runnable接口刚好匹配这个签名，所以不用自定义接口：

public class GenericMethodDemo {
    // 泛型方法接收对象和对应的方法引用
    public static <T> void executeAction(T obj, Runnable action) {
        action.run();
    }

    static class Foo {
        public void doSomething() {
            System.out.println("Foo is doing something");
        }
    }

    static class Bar {
        public void doSomething() {
            System.out.println("Bar is doing something");
        }
    }

    public static void main(String[] args) {
        Foo foo = new Foo();
        // 传入方法引用foo::doSomething，编译器会自动适配为Runnable
        executeAction(foo, foo::doSomething);

        Bar bar = new Bar();
        executeAction(bar, bar::doSomething);
    }
}

如果目标方法有参数或返回值，比如int calculate(int num)，我们可以用内置的Function<Integer, Integer>，或者自定义更贴合业务的接口：

@FunctionalInterface
interface Calculator {
    int calculate(int num);
}

public static <T> int executeCalculate(T obj, Calculator calc, int input) {
    return calc.calculate(input);
}

// 调用示例
static class MathTool {
    public int calculate(int num) {
        return num * 2;
    }
}

MathTool tool = new MathTool();
executeCalculate(tool, tool::calculate, 5); // 返回10

这种方式的优势：

• 编译期就能检查方法是否存在、签名是否匹配，避免运行时错误
• 性能和直接调用方法几乎一致
• 代码可读性更高，更符合Java的静态类型风格

为什么泛型本身做不到？ #

Java的泛型是类型擦除实现的，编译后泛型类型信息会被擦除为Object。而且泛型的类型参数约束（extends/super）只能指定类或接口，无法只通过方法名来约束——毕竟Java没有“鸭子类型”的语法支持，必须通过显式的类型契约（接口/继承）或者上述的反射、方法引用来模拟。

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