返回两个或更多泛型类型的Java方法

Question

关于返回通用类型的Java方法有很多问题，但是到目前为止，没有一个问题对我有帮助。

所以这是我的代码：

interface DAO<K, T> {
   void    insert(T t);
   void    update(K k, T t);
   void    delete(K k);
   void    delete();
   T       select(K k);
   List<T> select();
}

public class CourseDAO implements DAO<String, Course> {
   public void         insert(Course t) {}
   public void         update(String k, Course t) {}
   public void         delete(String k) {}
   public void         delete() {}
   public Course       select(String k) {}
   public List<Course> select() {}
}

public class StudentDAO implements DAO<Long, Student> {
   public void          insert(Student t) {}
   public void          update(Long k, Student t) {}
   public void          delete(Long k) {}
   public void          delete() {}
   public Student       select(Long k) {}
   public List<Student> select() {}
}

public enum EntityType { COURSE, STUDENT }

现在，我想它接受一个工厂方法EntityType参数和返回的实例CourseDAO或StudentDAO取决于参数值。

我尝试了以下代码，但未成功：

public <K,T> DAO<K,T> createDAOFactory(EntityType type) {
   switch (type) {
      case COURSE  : return (K,T) new CourseDAO();  break;
      case STUDENT : return (K,T) new StudentDAO(); break;
   }
   return null;
}

谁能帮助我编写和调用此方法？？？

干杯，
罗穆阿尔。

Answer 1

您要查找的演员表是(DAO<K,T>) 。 但是您会收到警告，因为通用类型擦除使其不安全。 switch工厂的另一个固有风险是，当您添加新的EntityType时，您可能会忘记创建相应的case 。 一种更安全的选择是使用通用类型重新定义EntityType ，并将其设置为工厂。 不幸的是，使用适当的枚举是不可能的，但是您可以像这样模拟它：

abstract class EntityType<K, T> {
    public abstract DAO<K, T> createDAO();

    public static final EntityType<String, Course> COURSE = new EntityType<String, Course>() {
        @Override
        public DAO<String, Course> createDAO() {
            return new CourseDAO();
        }
    };
    public static final EntityType<Long, Student> STUDENT = new EntityType<Long, Student>() {
        @Override
        public DAO<Long, Student> createDAO() {
            return new StudentDAO();
        }
    };
}

或者，您可以使用lambda来减少样板：

class EntityType<K, T> {
    private final Supplier<DAO<K, T>> constructor;

    private EntityType(Supplier<DAO<K, T>> constructor) {
        this.constructor = constructor;
    }

    public DAO<K, T> createDAO() {
        return constructor.get();
    }

    public static final EntityType<String, Course> COURSE = new EntityType<>(CourseDAO::new);
    public static final EntityType<Long, Student> STUDENT = new EntityType<>(StudentDAO::new);
}

现在，您不必调用createDAOFactory(EntityType.COURSE) ，而只需调用EntityType.COURSE.createDAO() 。

Answer 2

也许你可以这样吗？

public class StudentDAO<Long,Student> implements DAO<Long, Student> {
    public void          insert(Student t) {}
    public void          update(Long k, Student t) {}
    public void          delete(Long k) {}
    public void          delete() {}
    public Student       select(Long k) {return null;}
    public List<Student> select() {return null;}
}

public <K,T> DAO<K,T>createDAOFactory(EntityType type) {
    switch (type) {
        case COURSE  : return new CourseDAO();
        case STUDENT : return new StudentDAO();
    }
    return null;
}

---

第一个答案

您不需要使用泛型，因为实现类已经指定了类型。

public DAO createDAOFactory(EntityType type) {
    switch (type) {
        case COURSE  : return new CourseDAO();
        case STUDENT : return new StudentDAO();
    }
    return null;
}