Java泛型对象方法调用的策略：反射与接口设计

import java.lang.reflect.Method;
import java.util.Arrays;

public class ReflectionMethodCaller {

    /**
     * 通过反射机制调用对象的getId()方法。
     * 如果对象没有getId()方法，则抛出NoSuchMethodException。
     *
     * @param item 任意Java对象
     * @return getId()方法的返回值，转换为String类型
     * @throws NoSuchMethodException 如果对象没有getId()方法
     * @throws Exception 调用方法时可能抛出的其他异常（如IllegalAccessException, InvocationTargetException）
     */
    public String getObjectIdReflectively(Object item) throws Exception {
        // 尝试获取getId()方法
        Method getIdMethod;
        try {
            // getMethod() 会查找公共方法，包括继承的方法
            getIdMethod = item.getClass().getMethod("getId");
        } catch (NoSuchMethodException e) {
            // 如果方法不存在，则抛出自定义异常或处理
            throw new NoSuchMethodException("对象 " + item.getClass().getName() + " 未实现公共的 getId() 方法。", e);
        }

        // 动态调用方法
        Object result = getIdMethod.invoke(item);
        return result == null ? null : result.toString();
    }

    // 示例类 A，包含 getId() 方法
    static class ClassA {
        public String getId() {
            return "A-123";
        }
    }

    // 示例类 B，不包含 getId() 方法
    static class ClassB {
        public String getName() {
            return "Test B";
        }
    }

    public static void main(String[] args) {
        ReflectionMethodCaller caller = new ReflectionMethodCaller();

        // 测试 ClassA (有 getId 方法)
        ClassA a = new ClassA();
        try {
            System.out.println("ClassA ID: " + caller.getObjectIdReflectively(a)); // 预期输出: A-123
        } catch (Exception e) {
            System.err.println("调用 ClassA 的 getId 方法时出错: " + e.getMessage());
        }

        // 测试 ClassB (没有 getId 方法)
        ClassB b = new ClassB();
        try {
            System.out.println("ClassB ID: " + caller.getObjectIdReflectively(b));
        } catch (Exception e) {
            System.err.println("调用 ClassB 的 getId 方法时出错: " + e.getMessage()); // 预期输出: NoSuchMethodException
        }
    }
}

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 定义一个可识别的接口，所有实现该接口的类都必须提供getId方法。
 */
public interface Identifiable {
    String getId();
    // 根据需要，可以添加其他方法，例如 void setId(String value);
}

/**
 * 实现Identifiable接口的类A。
 */
class MyClassA implements Identifiable {
    private String id;
    private String name;

    public MyClassA(String id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String getId() {
        return id;
    }
}

/**
 * 实现Identifiable接口的类B。
 */
class MyClassB implements Identifiable {
    private String uniqueId;
    private int version;

    public MyClassB(String uniqueId, int version) {
        this.uniqueId = uniqueId;
        this.version = version;
    }

    @Override
    public String getId() {
        return uniqueId;
    }
}

public class InterfaceMethodCaller {

    /**
     * 接收Identifiable类型的对象，并调用其getId()方法。
     * 这种方式在编译时就能保证getId()方法的存在。
     *
     * @param item 实现了Identifiable接口的对象
     * @return 对象的ID
     */
    public String getObjectId(Identifiable item) {
        return item.getId(); // 编译时安全，直接调用
    }

    /**
     * 从Identifiable对象的集合中提取所有ID。
     * 使用泛型通配符 <? extends Identifiable> 允许传入 Identifiable 及其子类型的集合。
     *
     * @param items 实现了Identifiable接口的对象的集合
     * @return 所有对象的ID列表
     */
    public List<String> getAllObjectIds(Collection<? extends Identifiable> items) {
        return items.stream()
                   .map(Identifiable::getId) // 使用方法引用，简洁高效
                   .collect(Collectors.toList());
    }

    public static void main(String[] args) {
        InterfaceMethodCaller caller = new InterfaceMethodCaller();

        MyClassA a = new MyClassA("ID_A_001", "Instance A");
        MyClassB b = new MyClassB("ID_B_002", 1);

        System.out.println("MyClassA ID: " + caller.getObjectId(a)); // 输出: ID_A_001
        System.out.println("MyClassB ID: " + caller.getObjectId(b)); // 输出: ID_B_002

        List<Identifiable> identifiableList = new ArrayList<>();
        identifiableList.add(a);
        identifiableList.add(b);

        System.out.println("所有ID列表: " + caller.getAllObjectIds(identifiableList)); // 输出: [ID_A_001, ID_B_002]

        // 尝试传入一个未实现Identifiable接口的普通Object，会发生编译错误
        // Object obj = new Object();
        // System.out.println(caller.getObjectId((Identifiable) obj)); // 编译错误或运行时ClassCastException
    }
}