类设计-手动强制转换替代方案

Question

问题与下面的类相关。Zookeeper1和Zookeeper2是我可以使用的两个替代方案。我可以在未来在Zookeeper中存储不同类型的动物。我应该能够得到这些类。在第一种情况下，我将所有的动物存储在列表中(这意味着将来我可以很容易地添加其他新的动物)，但当我需要获得它时，我需要使用( dog )来投掷狗。在某个地方读到强制转换是代码嗅觉，所以我想看看有没有其他选择？其他解决方案会阻止强制转换，但每次我添加新动物时都会出现添加新列表的问题。

class AnimalId{}

interface Animal{
    AnimalId getAnimalId();
    void breathe();
}

class Cat implements Animal{
    public AnimalId getAnimalId() { return null; }
    public void breathe() {}
}

class Dog implements Animal{
    public AnimalId getAnimalId() { return null; }
    public void breathe() {}
    public void bark(){}
}

class ZooKeeper1{
    Map<AnimalId, Animal> animals = new HashMap<>();    //future-proof

    void addAnimal(Animal a){
        animals.put(a.getAnimalId(), a);
    }

    void printAnimals(){
        animals.forEach((key, value) -> System.out.println(key));
    }

    Dog getDog(AnimalId animalId){
        return (Dog)animals.get(animalId);  //NOK - must type-cast!
    }

    public static void main(String[] args) {
        ZooKeeper1 zk1 = new ZooKeeper1();
        zk1.addAnimal(new Cat());
        zk1.addAnimal(new Dog());
        zk1.printAnimals();
        Dog d = zk1.getDog(new AnimalId());
        d.bark();
    }
}

class ZooKeeper2{
    Map<AnimalId, Cat> cats = new HashMap<>();
    Map<AnimalId, Dog> dogs = new HashMap<>();  //will need to add more lines in future

    void addCat(Cat c){
        cats.put(c.getAnimalId(), c);
    }

    void addDog(Dog d){
        dogs.put(d.getAnimalId(), d); //will need to add more lines in future
    }

    void printAnimals(){
        cats.forEach((key, value) -> System.out.println(key));
        dogs.forEach((key, value) -> System.out.println(key)); //will need to add more lines in future
    }

    Dog getDog(AnimalId animalId){
        return dogs.get(animalId);  //OK no type-cast
    }

    public static void main(String[] args) {
        ZooKeeper2 zk2 = new ZooKeeper2();
        zk2.addCat(new Cat());
        zk2.addDog(new Dog());
        zk2.printAnimals();
        Dog d = zk2.getDog(new AnimalId());
        d.bark();
    }
}

Answer 1

好的，那么在研究了Java中的异构容器之后，我想这将是到目前为止我有的最好的选择？对这类解决方案有什么意见吗？

interface Animal { AnimalId getId(); }
class AnimalId { int id; AnimalId(int id){this.id = id;} public boolean equals(Object o){ return id==((AnimalId)o).id; } public int hashCode(){ return 1; } }
class Cat implements Animal { AnimalId id; Cat(AnimalId id){this.id=id;} public AnimalId getId(){ return id; } public String catSpecific(){ return "CS"; } }
class Dog implements Animal { AnimalId id; Dog(AnimalId id){this.id=id;} public AnimalId getId(){ return id; } public String dogSpecific(){ return "DS"; } }

class Zoo {
    private Map<Class<? extends Animal>, Map<AnimalId, Animal>> animals = new HashMap<>();

    public <T extends Animal> void assignAnimal(T animal){
        animals.computeIfAbsent(animal.getClass(), k -> new HashMap<>()).put(animal.getId(), animal);
    }

    public <T extends Animal> T getAnimal(Class<T> type, AnimalId animalId){
        return type.cast(animals.get(type).get(animalId));
    }

    public static void main(String[] args) {
        Zoo zoo = new Zoo();

        AnimalId animalId = new AnimalId(1);
        Animal animal1 = new Cat(animalId);
        Animal animal2 = new Dog(animalId);

        zoo.assignAnimal(animal1);
        zoo.assignAnimal(animal2);

        Cat cat = zoo.getAnimal(Cat.class, animalId);
        Dog dog = zoo.getAnimal(Dog.class, animalId);

        System.out.println(cat.catSpecific());
        System.out.println(dog.dogSpecific());
    }
}

Answer 2

想象一下，我在不了解Dog类的情况下编写了ZooKeeper1类，并将其传递给了您。然后，您决定扩展该类并添加方法Dog getDog(AnimalId id)。

你希望这能正常工作吗？如果你看到了推理中的差距，那么你就明白为什么选角是个坏主意了。

铸造并不是一个神奇的解决方案。使用它的唯一安全方法是仅强制转换已知类型的对象；例如，如果将Dog实例存储在类型为Animal的变量中，则可以肯定地将getAnimal(..)的结果强制转换为类型Dog。