Java中处理泛型对象方法调用的策略：反射与接口实践

import java.util.Arrays;

public class GenericMethodCaller {

    // 编译时会报错：cannot find symbol - method getId()
    public String getObjectId(Object item) throws Exception {
        // 这段运行时检查是有效的，但编译器不认
        if (Arrays.stream(item.getClass().getMethods())
            .filter(method -> "getId".equals(method.getName()))
            .findFirst()
            .isEmpty()) {
          throw new Exception("Method 'getId()' not found on object of type: " + item.getClass().getName());
        }

        // 尽管上面已经验证过，但编译器在编译时仍然不知道Object类型有getId()方法
        return item.getId(); // 编译错误：cannot find symbol
    }

    // 示例用法（编译不通过，无法运行）
    public static void main(String[] args) {
        // 假设有一个类MyClass实现了getId()
        // MyClass myObject = new MyClass();
        // new GenericMethodCaller().getObjectId(myObject);
    }
}

// 假设存在这样一个类
class MyClass {
    public String getId() {
        return "myId123";
    }
}

import java.lang.reflect.Method;
import java.lang.reflect.InvocationTargetException;

public class ReflectionMethodCaller {

    /**
     * 通过反射动态调用对象的getId()方法。
     * @param item 任意对象
     * @return getId()方法的返回值，如果方法不存在或返回null则返回null，
     *         如果返回值不是String类型，会尝试转换为String。
     * @throws NoSuchMethodException 如果对象没有getId()方法
     * @throws IllegalAccessException 如果getId()方法不可访问
     * @throws InvocationTargetException 如果getId()方法内部抛出异常
     */
    public String getObjectIdByReflection(Object item)
            throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
        // 1. 获取对象的Class对象
        Class<?> clazz = item.getClass();

        // 2. 获取名为"getId"的公共方法，不带参数
        // 如果getId()方法有参数，需要在这里指定参数类型，例如：getMethod("getId", String.class)
        Method getIdMethod = clazz.getMethod("getId");

        // 3. 调用方法
        Object result = getIdMethod.invoke(item);

        // 4. 处理返回值
        return result == null ? null : result.toString();
    }

    // 示例用法
    public static void main(String[] args) {
        MyClass myObject = new MyClass();
        AnotherClass anotherObject = new AnotherClass();
        NoIdClass noIdObject = new NoIdClass();

        ReflectionMethodCaller caller = new ReflectionMethodCaller();

        try {
            System.out.println("MyClass getId: " + caller.getObjectIdByReflection(myObject)); // 输出: MyClass getId: myId123
            System.out.println("AnotherClass getId: " + caller.getObjectIdByReflection(anotherObject)); // 输出: AnotherClass getId: anotherId456
            // 尝试调用没有getId方法的对象，会抛出NoSuchMethodException
            System.out.println("NoIdClass getId: " + caller.getObjectIdByReflection(noIdObject));
        } catch (NoSuchMethodException e) {
            System.err.println("错误：对象 " + e.getMessage().split(" ")[0] + " 没有 getId() 方法。");
        } catch (IllegalAccessException | InvocationTargetException e) {
            System.err.println("调用方法时发生错误：" + e.getMessage());
        }
    }
}

// 示例类
class MyClass {
    public String getId() {
        return "myId123";
    }
}

class AnotherClass {
    public String getId() {
        return "anotherId456";
    }
}

class NoIdClass {
    // 没有getId()方法
}

/**
 * 定义一个标识符接口，所有可获取ID的对象都应实现此接口。
 */
public interface Identifiable {
   String getId(); // 获取对象的唯一标识符

   // 可选：如果需要设置ID，也可以添加此方法
   // void setId(String value);
}

// 示例类A实现Identifiable接口
class ClassA implements Identifiable {
    private String id;
    private String name;

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

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

    // 其他方法...
    public String getName() {
        return name;
    }
}

// 示例类B实现Identifiable接口
class ClassB implements Identifiable {
    private String uniqueId;
    private int value;

    public ClassB(String uniqueId, int value) {
        this.uniqueId = uniqueId;
        this.value = value;
    }

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

    // 其他方法...
    public int getValue() {
        return value;
    }
}

// 一个不实现Identifiable接口的类
class ClassC {
    private String data;
    public ClassC(String data) { this.data = data; }
    public String getData() { return data; }
}

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

public class InterfaceMethodCaller {

    /**
     * 接收一个Identifiable对象，并调用其getId()方法。
     * 这是一个编译时安全的调用。
     * @param item 实现了Identifiable接口的对象
     * @return 对象的ID
     */
    public String getObjectIdByInterface(Identifiable item) {
        return item.getId(); // 编译时安全，无反射开销
    }

    // 示例用法
    public static void main(String[] args) {
        Collection<Identifiable> identifiableItems = new ArrayList<>();
        identifiableItems.add(new ClassA("A001", "Item A"));
        identifiableItems.add(new ClassB("B002", 100));
        // identifiableItems.add(new ClassC("C003")); // 编译错误：ClassC未实现Identifiable接口

        // 使用Java 8 Stream API收集所有ID
        List<String> ids = identifiableItems.stream()
                                            .map(Identifiable::getId) // 方法引用，编译时安全
                                            .collect(Collectors.toList());

        System.out.println("所有可标识对象的ID: " + ids); // 输出: 所有可标识对象的ID: [A001, B002]

        // 单个对象调用
        InterfaceMethodCaller caller = new InterfaceMethodCaller();
        ClassA itemA = new ClassA("A003", "Another A");
        System.out.println("单个ClassA对象的ID: " + caller.getObjectIdByInterface(itemA)); // 输出: 单个ClassA对象的ID: A003
    }
}