我试图在 java 中创建两个相互包含的类之间的泛型关系。这些对象本质上形成了交替层树。到目前为止，我发现的最接近的 SO 问题是:Java generics of generics of ，这对我的问题很接近并且有些帮助，但仍然不同，我需要更多指导。这是情况，或者更确切地说，我希望它是这样的:

abstract class Group<I extends Item<Group<I>>>{
     private List<I> items;
     public List<I> getItems(){...}
     public void setItems(List<I> items){...}
}

abstract class Item<G extends Group<Item<G>>>{
     private List<G> subGroups;
     public List<G> getSubGroups(){...}
     public void setSubGroups(List<G> subGroups){...}
}

除了 getter 和 setter 之外，类的某些方面也使它们彼此明显不同，但包含应该遵循这样的原则。这背后的原因是我想强制执行，如果我有实现类，它们必须表现得像这样:

class AGroup extends Group<AItem>{...} //works
class AItem extends Item<AGroup>{...} //works
class BGroup extends Group<BItem>{...} //works
class BItem extends Item<BGroup>{...} //works
class MixedGroup extends Group<AItem>{...} //fails since AItem does
                                           //not extend Item<MixedGroup>

到目前为止，编译器没问题

abstract class Group<I extends Item<Group<I>>>{
     private List<I> items;
     public List<I> getItems(){...}
     public void setItems(List<I> items){...}
}

abstract class Item<G extends Group>{ //raw types warning
     private List<G> subGroups;
     public List<G> getSubGroups(){...}
     public void setSubGroups(List<G> subGroups){...}
}

这主要涵盖了我正在寻找的内容，因为我知道我可以获得一个组的项目的子组并返回相同类型的组。但是编译器不知道如果我得到一个项目的组的项目，我会得到相同类型的项目(例如，该项目可能是孤立的)。此外，原始类型警告总是让我觉得我做错了什么。此外，如果有更好的方法来执行这种类绑定(bind)，我很想听听。

最佳答案

您可以尝试以下方法:

abstract class Group<I extends Item<I, G>, G extends Group<I, G>> {
     private List<I> items;
     public List<I> getItems() { return null; }
     public void setItems(List<I> items) { }
}

abstract class Item<I extends Item<I, G>, G extends Group<I, G>> {
     private List<G> subGroups;
     public List<G> getSubGroups() { return null; }
     public void setSubGroups(List<G> subGroups) { }
}

class AGroup extends Group<AItem, AGroup> { }         // works
class AItem extends Item<AItem, AGroup> { }           // works
class BGroup extends Group<BItem, BGroup> { }         // works
class BItem extends Item<BItem, BGroup> { }           // works
class MixedGroup extends Group<AItem, MixedGroup> { } // fails

( ideone )

使用两个类型参数的原因是因为每个类型都用一个相反的类型进行参数化，每个类型都需要跟踪对方的类型和它自己的“自身类型”。

这可以推广到任意数量的“参与”类型:

// one type
interface SelfParameterized<T extends SelfParameterized<T>> { }

// two types
interface SelfParameterizedPairA<
        A extends SelfParameterizedPairA<A, B>,
        B extends SelfParameterizedPairB<A, B>
> { }
interface SelfParameterizedPairB<
        A extends SelfParameterizedPairA<A, B>,
        B extends SelfParameterizedPairB<A, B>
> { }

// three types
interface SelfParameterizedTrioA<
        A extends SelfParameterizedTrioA<A, B, C>,
        B extends SelfParameterizedTrioB<A, B, C>,
        C extends SelfParameterizedTrioC<A, B, C>
> { }
interface SelfParameterizedTrioB<
        A extends SelfParameterizedTrioA<A, B, C>,
        B extends SelfParameterizedTrioB<A, B, C>,
        C extends SelfParameterizedTrioC<A, B, C>
> { }
interface SelfParameterizedTrioC<
        A extends SelfParameterizedTrioA<A, B, C>,
        B extends SelfParameterizedTrioB<A, B, C>,
        C extends SelfParameterizedTrioC<A, B, C>
> { }

然而，这些类型的递归泛型的使用和实现往往过于复杂并且很少有好处(我在这篇文章中描述了一个用例:Is there a way to refer to the current type with a type variable?)。最好退一步重新评估您的设计，看看这种双向通用关系是否真的有必要。 More often than not我发现递归泛型源于一种试图做太多事情的类型，其职责应该分离为多个更简单的类型。

关于Java 泛型 2 向引用，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/21048182/