Java 如何正确使用泛型来解决此编译错误？

重复前面的一个例子，想象一个动物园，新来的动物必须由动物园管理员“处理”（想想把它们送到动物园）。每种动物的登记过程取决于其分类（哺乳动物、鸟类等）

这些过程的不同是因为分类类别之间的根本差异——例如，鸟类有翅膀，哺乳动物有牙齿。你们可能也有一些对所有动物都适用的过程共享片段，但我在这里省略了它们

代码如下：

Animal.java

public interface Animal {

    public AnimalProcessor<? extends Animal> getAnimalProcessor();
}

Condor.java

public class Condor extends Bird {

    @Override
    public float getWingspan() {
        return 2.9f;
    }
}

ZooKeeper.java

import java.util.List;

public class ZooKeeper {

    public void processNewAnimals(List<Animal> newcomers)
    {
        for(Animal critter : newcomers)
        {
            AnimalProcessor<? extends Animal> ap = critter.getAnimalProcessor();

                        // This line has a compilation error!
            ap.process(critter);
        }
    }
}

import java.util.List；
公营动物园管理员{
新动物（列出新来者）
{
用于（动物生物：新来者）
{
AnimalProcessor
公共接口动物{
AnimalProcessor getAnimalProcessor（）；
}
公共抽象类哺乳动物实现动物{

有点像
Enum

最好删除该方法。
AnimalProcessor.java：

public interface AnimalProcessor<T extends Animal> {
    public void process(Animal critter);
}

公共接口动物处理器{
公共程序（动物）；
}

java处理器

public interface AnimalProcessor<T extends Animal> {

    public void process(T critter);
}

public class MammalProcessor implements AnimalProcessor<Mammal> {

    @Override
    public void process(Mammal a) {
        System.out.println("Tooth count is " + a.getToothCount());
    }

}

public class BirdProcessor implements AnimalProcessor<Bird> {

    @Override
    public void process(Bird a) {
        System.out.print("Wingspan is " + a.getWingspan());
    }

}

public class MammalProcessor implements AnimalProcessor<Mammal> {
    @Override
    public void process(Animal a) {
        System.out.println("Tooth count is " + ((Mammal)a).getToothCount());
    }
}

public类处理器实现AnimalProcessor{
@凌驾
公共无效程序（动物a）{
System.out.println（“牙齿计数为”+（（哺乳动物）a.getToothCount（））；
}
}
为什么Animal是一个接口而不是一个抽象类？接口应该是某种共享行为。我同意你的观点，我在代码中对其进行了更改-但编译错误仍然存在。我不相信我以前见过这种方法？它有名称吗？抱歉，删除哪个方法？getAnimalProcessor（）？在这种情况下，如何使代码的其余部分发挥作用？我应该指出，我特意添加了getAnimalProcessor方法，以便将两个并行继承层次结构（Animal vs AnimalProcessor）联系在一起。在我的理想世界中，我不会让动物知道它将如何被处理……这样我就可以在动物园、农场或配色系统中重复使用我的动物，而不会产生污染代码。@pjm56照原样，你可以用
过程
替换
getAnimalProcessor
。如果你不想
动物
的话了解
AnimalProcessor
s，当你构建
AnimalProcessor
时，用相关的
AnimalProcessor
将其打包到另一个对象中。感谢Iga-我可以看出这是可行的，但我希望我可以巧妙地使用泛型来避免这种负面影响。我认为你无法回避的根本原因是getAnimalProcessor方法允许您拉出一种动物的处理器，并可能将其用于任何其他动物（可能是错误的子类型）。在某些类型匹配的地方，如果不果断地使用强制类型转换，可能不可能“摆正此圆”。有关于此类强制类型转换的样式建议吗？
import java.util.List;

public class ZooKeeper {

    public void processNewAnimals(List<Animal> newcomers)
    {
        for(Animal critter : newcomers)
        {
            AnimalProcessor<? extends Animal> ap = critter.getAnimalProcessor();

                        // This line has a compilation error!
            ap.process(critter);
        }
    }
}

import java.util.LinkedList;
import java.util.List;

public class MainClass {

    public static void main(String[] args) {

        ZooKeeper keeper = new ZooKeeper();

        List<Animal> animals = new LinkedList<Animal>();

        animals.add(new Badger());
        animals.add(new Condor());

        keeper.processNewAnimals(animals);

    }
}

public interface Animal<THIS extends Animal<THIS>> {
    AnimalProcessor<THIS> getAnimalProcessor();
}
public abstract class Mammal implements Animal<Mammal> {

public interface AnimalProcessor<T extends Animal> {
    public void process(Animal critter);
}

public class MammalProcessor implements AnimalProcessor<Mammal> {
    @Override
    public void process(Animal a) {
        System.out.println("Tooth count is " + ((Mammal)a).getToothCount());
    }
}