Java中的泛型转换

Question

下面泛型方法定义中，会有啥问题吗？主要是 1 和 3 那样强制转换有问题吗？
当然 Cat 和 Dog 是 extends 了 Animal 类

<T extends Animal> void operate(List<T> animalList, Class<T> c){
    ...
    if(c.equals(Cat.class)){
        List catList = (List<Cat>) animalList;             //1     
        catDao.insert(catList);                           //2
    }

    if(c.equals(Dog.class)){
        List<Dog> dogList = (List<Dog>) animalList;        //3 
        dogDao.insert(dogList);                           //4
    }
    ...
}

其中 insert()函数定义为：

catDao.insert(List<Cat> catList);
dogDao.insert(List<Dog> dogList);

Answer 1

这个转换没什么问题，但总给人一种坏味道的感觉。建议使用工厂模式，这样判断就与操作解耦出来了。

Answer 2

你看能不能这么写呢？尽管逻辑和你原来的代码有所不同，但可以达到同样的目的。

void operate(List<? extends Animal> animalList) {
    List<Cat> catList = new ArrayList<>();
    List<Cat> dogList = new ArrayList<>();
    for (Animal animal : animalList) {
       if (animal instanceof Cat) {
           catList.add((Cat) animal);
       }
       if (animal instanceof Dog) {
           dogList.add((Dog) animal);
       }
    }
    catDao.insert(catList);
    dogDao.insert(dogList);
}

Answer 3

并不建议这么做，因为这失去了继承的意义。没有获得继承带来的好处，却要背负维护继承关系的负担。这买卖不划算啊，是不？
可以考虑这么做：

1. 增加一个AnimalDAO:

   public class AnimalDAO<T extends Animal> {
       public void insert(List<T> animals) {
           System.out.println("Animals have been inserted.");
       }
   }

2. 调用的客户端:

   public class AnimalClient {
       public static void main(String[] args) {
           List<Cat> cats = Stream.of(new Cat()).collect(Collectors.toList());
           List<Dog> dogs = Stream.of(new Dog()).collect(Collectors.toList());
           
           operate(cats);
           operate(dogs);
       }
       
       public static <T extends Animal> void operate(List<T> animals) {
           AnimalDAO<T> animalDAO = new AnimalDAO<>();
           animalDAO.insert(animals);
       }
   }

   • 编译通过，运行结果：

     Animals have been inserted
     Animals have been inserted