Java能否基于方法存在而非类/接口实现泛型？

Java（包括最新版本）不支持基于"方法存在"的结构类型（Structural Typing）——也就是TypeScript里常用的"鸭子类型"特性。你无法直接通过泛型约束来要求某个类型必须包含getCode()方法，而不需要它实现特定接口或继承父类。

不过有几种替代方案可以实现类型安全的通用缓存，避免反射方案的编译时无校验问题：

方案1：适配器模式（Adapter Pattern） #

为每个无法修改的类编写适配器，让适配器实现统一的接口，缓存类基于该接口做泛型约束。

步骤1：定义统一接口 #

public interface HasCode {
    String getCode();
}

步骤2：编写适配器类 #

给每个现有类创建适配器，包装原对象并实现HasCode接口：

public class MyClass1Adapter implements HasCode {
    private final MyClass1 target;

    public MyClass1Adapter(MyClass1 target) {
        this.target = target;
    }

    @Override
    public String getCode() {
        return target.getCode();
    }

    // 可选：暴露原对象的访问方法
    public MyClass1 getTarget() {
        return target;
    }
}

// MyClass2的适配器同理
public class MyClass2Adapter implements HasCode {
    private final MyClass2 target;

    public MyClass2Adapter(MyClass2 target) {
        this.target = target;
    }

    @Override
    public String getCode() {
        return target.getCode();
    }
}

步骤3：类型安全的缓存类 #

public class CodeBasedCache<T extends HasCode> {
    private final Map<String, T> cache = new HashMap<>();

    public T get(T obj) {
        String key = obj.getClass().getEnclosingClass().getSimpleName() + obj.getCode();
        return cache.get(key);
    }

    public void put(T obj) {
        String key = obj.getClass().getEnclosingClass().getSimpleName() + obj.getCode();
        cache.put(key, obj);
    }
}

使用示例 #

CodeBasedCache<HasCode> cache = new CodeBasedCache<>();
cache.put(new MyClass1Adapter(new MyClass1()));
cache.put(new MyClass2Adapter(new MyClass2()));

优点：完全的编译时类型校验，类型安全；缺点：需要为每个类编写适配器，适合类数量不多的场景。

方案2：函数式接口+方法引用 #

利用Java 8+的函数式接口，将getCode()方法的提取逻辑作为参数传入缓存类，避免编写适配器。

步骤1：定义函数式接口 #

@FunctionalInterface
public interface CodeExtractor<T> {
    String extractCode(T obj);
}

步骤2：通用缓存类 #

public class CodeBasedCache<T> {
    private final Map<String, T> cache = new HashMap<>();
    private final CodeExtractor<T> codeExtractor;

    public CodeBasedCache(CodeExtractor<T> codeExtractor) {
        this.codeExtractor = codeExtractor;
    }

    public T get(T obj) {
        String code = codeExtractor.extractCode(obj);
        String key = obj.getClass().getSimpleName() + code;
        return cache.get(key);
    }

    public void put(T obj) {
        String code = codeExtractor.extractCode(obj);
        String key = obj.getClass().getSimpleName() + code;
        cache.put(key, obj);
    }
}

使用示例 #

// 针对MyClass1的缓存实例
CodeBasedCache<MyClass1> cache1 = new CodeBasedCache<>(MyClass1::getCode);
cache1.put(new MyClass1());

// 针对MyClass2的缓存实例
CodeBasedCache<MyClass2> cache2 = new CodeBasedCache<>(MyClass2::getCode);
cache2.put(new MyClass2());

// 如需统一管理不同类型缓存，可借助Map
Map<Class<?>, CodeBasedCache<?>> cacheMap = new HashMap<>();
cacheMap.put(MyClass1.class, cache1);
cacheMap.put(MyClass2.class, cache2);

优点：无需编写适配器，代码简洁；缺点：单个缓存实例只能处理一种类型，统一管理需要额外处理。

方案3：反射方案的改进（仍为运行时校验） #

如果不想编写额外类，可以在反射基础上增加前置检查，提前抛出异常：

public class CodeBasedCache {
    private final Map<String, Object> cache = new HashMap<>();

    private void validateHasGetCode(Object obj) {
        try {
            obj.getClass().getMethod("getCode");
        } catch (NoSuchMethodException e) {
            throw new IllegalArgumentException("对象必须包含无参的getCode()方法", e);
        }
    }

    public Object get(Object obj) {
        validateHasGetCode(obj);
        try {
            String code = (String) obj.getClass().getMethod("getCode").invoke(obj);
            return cache.get(obj.getClass().getSimpleName() + code);
        } catch (Exception e) {
            throw new RuntimeException("获取code失败", e);
        }
    }

    public void put(Object obj) {
        validateHasGetCode(obj);
        try {
            String code = (String) obj.getClass().getMethod("getCode").invoke(obj);
            cache.put(obj.getClass().getSimpleName() + code, obj);
        } catch (Exception e) {
            throw new RuntimeException("存入缓存失败", e);
        }
    }
}

优点：无需修改原类；缺点：仍为运行时校验，编译阶段无法发现问题。

总结 #

Java没有结构类型特性，无法直接通过方法存在约束泛型。优先选择适配器模式或函数式接口方案，它们能提供编译时类型安全，避免运行时异常。

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