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

关于返回泛型类型的Java方法有很多问题，但目前为止他们都没有帮助我。返回两个或多个泛型类型的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; 
}

谁能帮我写，并调用此方法???

干杯，
Romualdo。

来源

2017-08-15 Romualdo Rubens de Freitas

你试图用这种工厂方法解决什么问题？据我所知，使用这种方法没有明智的方法（假设它可以编译开始）。 – Steven

如果我从保留DAO作为返回类型的方法签名中删除，并且从返回值中删除了（K，T），但是Eclipse会显示警告：“DAO是原始类型，对泛型类型DAO 的引用应该被参数化”。 –

是的，这是编译它的一种方法。但是，您打算如何调用此方法并使用它返回的DAO？ – Steven

您正在寻找的演员是(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()即可。

来源

2017-08-15 01:12:32 shmosel

嗨Shmosel，在你的第一个例子中，你能告诉我们工厂如何使用这个抽象类 –

@ScaryWombat它是**工厂。编辑澄清。 – shmosel

*你只需要调用*'EntityType.COURSE.createDAO（）'OK，这很有道理 –

也许你可以这样做？

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; 
}

来源

2017-08-15 01:14:30 flytosea

谢谢flytosea，我正在这样做。 Plz阅读了Steven的评论（上图）。 –

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

回答

相关问题