如何用相同方法创建不同类型对象？如何通过Helper方法管理多Repository对象？

嗨，这俩问题都是日常开发里很典型的面向对象设计场景，我给你一步步拆解解答：

当然有！最常用的就是工厂模式（Factory Pattern）——不管是简单工厂、工厂方法还是抽象工厂，核心思想就是用统一的接口/方法来封装不同对象的创建逻辑，调用方不用关心具体对象是怎么造出来的，只需要告诉工厂“我要什么类型的对象”就行。

举个简单例子，你可以写个ObjectFactory类，传入类型标识就返回对应实例：

public class ObjectFactory {
    public static <T> T createObject(Class<T> clazz) throws Exception {
        // 这里可以加自定义的创建逻辑，比如初始化参数等
        return clazz.getDeclaredConstructor().newInstance();
    }
}

调用的时候就一行：User user = ObjectFactory.createObject(User.class);，换别的类型直接换Class参数就行，完全统一的调用方式。

必须可以！而且结合上面的工厂思路，能把逻辑做得非常优雅，避免重复写“创建对象+加进Repo”的冗余代码。我给你两种实用的实现方案：

先铺垫基础代码 #

假设你的3个实体类和对应的Repository是这样的：

// 实体类
public class User {}
public class Product {}
public class Order {}

// Repository类，每个维护对应类型的ArrayList
public class UserRepository {
    private final List<User> users = new ArrayList<>();
    public void add(User user) { users.add(user); }
}

public class ProductRepository {
    private final List<Product> products = new ArrayList<>();
    public void add(Product product) { products.add(product); }
}

public class OrderRepository {
    private final List<Order> orders = new ArrayList<>();
    public void add(Order order) { orders.add(order); }
}

方案1：枚举映射+反射（灵活易扩展） #

先定义一个枚举，把实体类型和对应的Repository绑定，这样不用写一堆if-else判断：

public enum EntityType {
    USER(User.class, new UserRepository()),
    PRODUCT(Product.class, new ProductRepository()),
    ORDER(Order.class, new OrderRepository());

    private final Class<?> entityClass;
    private final Object repository;

    EntityType(Class<?> entityClass, Object repository) {
        this.entityClass = entityClass;
        this.repository = repository;
    }

    public Object getRepository() {
        return repository;
    }

    // 根据实体类找对应的枚举
    public static EntityType fromClass(Class<?> clazz) {
        for (EntityType type : values()) {
            if (type.entityClass.equals(clazz)) {
                return type;
            }
        }
        throw new IllegalArgumentException("找不到对应类型的处理规则：" + clazz);
    }
}

然后写Helper类，把“创建对象+添加到Repo”的逻辑封装成一个方法：

import java.lang.reflect.Method;

public class EntityHelper {
    @SuppressWarnings("unchecked")
    public <T> T createAndAddToRepository(Class<T> entityClass) throws Exception {
        // 1. 创建实体对象（假设实体类有默认构造方法）
        T entity = entityClass.getDeclaredConstructor().newInstance();
        
        // 2. 找到对应的Repository
        EntityType type = EntityType.fromClass(entityClass);
        Object repository = type.getRepository();
        
        // 3. 调用Repository的add方法（用反射适配不同类型的add）
        Method addMethod = repository.getClass().getMethod("add", entityClass);
        addMethod.invoke(repository, entity);
        
        return entity;
    }
}

方案2：函数式接口+映射表（类型安全，无反射） #

如果不想用反射（避免反射的性能和安全问题），可以用Java 8+的函数式接口来封装逻辑，类型更安全：

import java.util.HashMap;
import java.util.Map;
import java.util.function.Consumer;
import java.util.function.Supplier;

public class EntityHelper {
    // 维护实体类和对应的创建+添加逻辑
    private final Map<Class<?>, EntityHandler<?>> handlerMap = new HashMap<>();

    // 构造方法里注册每个实体的处理逻辑
    public EntityHelper(UserRepository userRepo, ProductRepository productRepo, OrderRepository orderRepo) {
        handlerMap.put(User.class, new EntityHandler<>(User::new, userRepo::add));
        handlerMap.put(Product.class, new EntityHandler<>(Product::new, productRepo::add));
        handlerMap.put(Order.class, new EntityHandler<>(Order::new, orderRepo::add));
    }

    // 统一的对外方法
    @SuppressWarnings("unchecked")
    public <T> T createAndAddToRepository(Class<T> entityClass) {
        EntityHandler<T> handler = (EntityHandler<T>) handlerMap.get(entityClass);
        if (handler == null) {
            throw new IllegalArgumentException("没有找到" + entityClass.getSimpleName() + "的处理逻辑");
        }
        // 创建对象并添加到Repo
        T entity = handler.createSupplier.get();
        handler.addConsumer.accept(entity);
        return entity;
    }

    // 内部类，封装创建和添加的逻辑
    private static class EntityHandler<T> {
        private final Supplier<T> createSupplier; // 创建对象的逻辑
        private final Consumer<T> addConsumer;    // 添加到Repo的逻辑

        public EntityHandler(Supplier<T> createSupplier, Consumer<T> addConsumer) {
            this.createSupplier = createSupplier;
            this.addConsumer = addConsumer;
        }
    }
}

怎么用？ #

两种方案的调用都非常简单：

public class Main {
    public static void main(String[] args) throws Exception {
        // 方案1的调用
        EntityHelper helper1 = new EntityHelper();
        User user1 = helper1.createAndAddToRepository(User.class);
        Product product1 = helper1.createAndAddToRepository(Product.class);

        // 方案2的调用
        UserRepository userRepo = new UserRepository();
        ProductRepository productRepo = new ProductRepository();
        OrderRepository orderRepo = new OrderRepository();
        EntityHelper helper2 = new EntityHelper(userRepo, productRepo, orderRepo);
        User user2 = helper2.createAndAddToRepository(User.class);
        Order order2 = helper2.createAndAddToRepository(Order.class);
    }
}

总结下：

• 问题1的核心是用工厂模式+泛型/反射实现统一创建逻辑；
• 问题2的关键是把“创建”和“添加到Repo”的逻辑绑定，用枚举或映射表避免重复代码，后续新增实体只需要扩展枚举或注册新的Handler，完全符合开闭原则。

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