在 java 中，提供参数以扩展参数化接口的接口是它的确切同义词吗？

Question

我想使用接口作为参数化接口的短名称，以避免使用通用语法污染所有代码。 例如：

EggChicken egg = chicken.lay();  // Can't make it compile.

代替：

Egg<AnimalChicken> egg = chicken.lay(); // Compiles happily.

假设我想 model 动物繁殖模式使用参数化类（ https://en.wikipedia.org/wiki/Modes_of_reproduction ）。 我有以下接口：

public interface Animal<T> {
   T lay();
}

interface Viviparous<T extends Viviparous> extends Animal<T> {
}

interface Egg<T extends Oviparous> {
    T hatch();
}

interface Oviparous<T extends Oviparous> extends Animal<Egg<T>> {
}

这个想法是胎生动物产下同一动物的新实例，而卵生动物产下的卵孵化同一动物的新实例。

现在，我想定义更精确的接口来描述狗和鸡：

interface AnimalDog extends Viviparous<AnimalDog> {
}

interface AnimalChicken extends Oviparous<AnimalChicken> {
}

interface EggChicken extends Egg<AnimalChicken> {
}

最后，这些是实现：

public class AnimalDogImpl implements AnimalDog {
    @Override
    public AnimalDog lay() {
        return new AnimalDogImpl();
    }
}

class AnimalChickenImpl implements AnimalChicken {
    @Override
    public EggChickenImpl lay() {
        return new EggChickenImpl();
    }
}

public class EggChickenImpl implements EggChicken {
    @Override
    public AnimalChicken hatch() {
        return new AnimalChickenImpl();
    }
}

当我想在代码中使用这些类时，我的问题就来了：

public class AnimalTest {
    @Test
    public void can_do_something_nice() {
        AnimalChicken chicken = new AnimalChickenImpl();
        // Error here:
        EggChicken egg = chicken.lay();
        AnimalChicken chick = egg.hatch();
       Assertions.assertThat(chick).isNotNull();
    }
}

我收到错误： Required EggChicken, found Egg<AnimalChicken> ，但这正是我定义EggChicken的方式。 是否有可能解决这种间接？

Answer 1

您要查找的内容称为类型别名。

Java 很遗憾没有它们。

当您创建一个新接口时，它定义了一个新类型。 EggChicken的实例也是Egg<Chicken>的实例，但反之则不然。 你必须让你的AnimalChicken （接口！）明确地返回一个EggChicken 。

Answer 2

总体思路是对的，但是层次有问题。 Animal不能直接产下Egg或Animal的类型，它们不相关。 我认为以下内容代表了您的意图：

    interface LayProduct {}

    interface Animal<E extends LayProduct> extends LayProduct{
        E lay();
    }

    interface Egg<E extends Egg<E,A>, A extends Oviparous<E,A>> extends LayProduct {
        A hatch();
    }

    interface Viviparous<A extends Viviparous<A>> extends Animal<A> {    }

    interface Oviparous<E extends Egg<E,A>, A extends Oviparous<E,A>> extends Animal<E> {    }


    interface AnimalDog extends Viviparous<AnimalDog> {
    }

    interface AnimalChicken extends Oviparous<EggChicken,AnimalChicken> {
    }

    interface EggChicken extends Egg<EggChicken,AnimalChicken> {
    }