Question

我目前正在使用Java进行继承。我想与您讨论以下情况。

在我的示例中，我有许多动物和围栏类。所有动物均来自BaseAnimal。所有附件均源自BaseEnclosure。这两个基类都提供了各种具体方法-还提供了一些抽象方法。

现在，在实现CatEnclosure时，我想指定在调用CatEnclosure.resettleTo(Enclosure)时只能传递一个cat防护罩。在我当前的代码中，还可以将猫和狗放在一起。

据我了解，在resettleTo类中创建抽象方法BaseEnclosure时，我必须定义将来（派生）类的类。

我的想法是使用第二个泛型。因此BaseEnclosure<A>成为BaseEnclosure<E, A>。但是现在我还必须指定E必须从BaseEnclosure派生。另外，当然，A也应该是BaseAnimal类型。

所以我得到：BaseEnclosure<E extends BaseEnclosure, A extends BaseAnimal>

我的IDE现在抱怨BaseEnclosure和BaseAnimal是原始类型。如果我写BaseEnclosure<E extends BaseEnclosure<?,?>, A extends BaseAnimal<?,?>>，它可以工作。但是，我不知道所有这些在设计方面是否有意义。

我期待您的建议。

随信附上示例代码。

public abstract class BaseAnimal<E> {
        protected E enclosure;
       
        public void setEnclosure(E enclosure) {
                this.enclosure = enclosure;
        }
       
        public E getEnclosure() {
                return enclosure;
        }
       
        public abstract String getNoise();
}

public abstract class BaseEnclosure<A> {
        protected List<A> animals = new ArrayList<A>();
       
        // some methods...
       
        public List<A> getAnimals() {
                return animals;
        }
       
        public abstract void resettleTo(BaseEnclosure other);
}

public class Cat extends BaseAnimal<CatEnclosure> {
 
        @Override
        public String getNoise() {
                return "miiiaaauu";
        }
}

public class CatEnclosure extends BaseEnclosure<Cat>{
 
        @Override
        public void resettleTo(BaseEnclosure other) {
                // hm...
        }
}

public class Dog extends BaseAnimal<DogEnclosure> {
 
        @Override
        public String getNoise() {
                return "wuff";
        }
}

public class DogEnclosure extends BaseEnclosure<Dog>{
 
        // some methods...
       
        @Override
        public void resettleTo(BaseEnclosure other) {
                // hm...
        }
}

public class Main {
       
        public static void main(String[] args) {
                DogEnclosure doghouse = new DogEnclosure();
                Dog dog = new Dog();
                // later: JPA
                doghouse.getAnimals().add(dog);
                dog.setEnclosure(doghouse);
               
                CatEnclosure catbox = new CatEnclosure();
                Cat cat = new Cat();
                // later: JPA
                catbox.getAnimals().add(cat);
                cat.setEnclosure(catbox);
               
                // OHOHOH!!!
                doghouse.resettleTo(catbox);
        }
}

Answer 1

我想指定的是，当调用CatEnclosure.resettleTo（Enclosure）时，只能传递一个Cat附件。在我当前的代码中，还可以将猫和狗放在一起。

假设在这里，您不希望CatEnclosure重新安置到DogEnclosure。

您的场景是泛型中循环引用的典型情况。基于此post，您需要按以下方式重新定义基类：

public abstract class BaseAnimal<A extends BaseAnimal<A, E>, E extends BaseEnclosure<E, A>> {...}

public abstract class BaseEnclosure<E extends BaseEnclosure<E, A>, A extends BaseAnimal<A, E>> {...}

class Dog extends BaseAnimal<Dog, DogEnclosure> {...}
class DogEnclosure extends BaseEnclosure<DogEnclosure, Dog> {...}
// Similarly Cat and CatEnclosure

现在，为了防止将猫围栏重置为狗围栏，您需要如下更改resettleTo方法签名：
public abstract void resettleTo(BaseEnclosure<E,A> other);

您将无法编译以下代码：

CatEnclosure catEnclosure = new CatEnclosure();
Cat c = new Cat();
c.setEnclosure(catEnclosure);

DogEnclosure dogEnclosure = new DogEnclosure();
Dog d = new Dog();
d.setEnclosure(dogEnclosure);

catEnclosure.resettleTo(dogEnclosure); // Error type mismatch

类继承和泛型类型

1 个答案: