Question

即使试图为此提出一个干净的标题也是一个挑战。

基本思想是定义两个超类：一个用于“子”项，其成员引用其“父”，另一个用于包含子对象的“父”列表。来自child-＆gt; parent和parent-＆gt; child的链接是对称的。每个父/子超类都有子类，用于定义和实现其他功能。总是有一个并行子类，以便子对与父对子。也就是说，parent只包含子引用，而child只引用父类 - 子类之间没有“交叉”。

我该如何表达这个？我已经坚持了好几天，而且我对多级嵌套泛型类型的创造性越强，它就越糟糕。这就是我想做的事情：

abstract class ChildBase<T extends ChildBase<T>> {
 ParentBase<T> parent;
}
abstract class ParentBase<T extends ChildBase<T>>  {
 LinkedList<T> childList;
}
class ChildSub extends ChildBase<ChildSub> {
 // ... class specific stuff
}
class ParentSub extends ParentBase<ChildSub> {
 // ... class specific stuff
}

这是一团糟。我怀疑有一种更为简单，直接的方式，这可能是一个完全不同的方向。

Answer 1

您的意思是class ParentSub extends ParentBase<ChildSub>吗？

如果你改变了这一点，它就会全部编译。

这是一团糟。我怀疑有一种更为简单，直接的方式，这可能是一个完全不同的方向。

实际上，与我使用仿制药的其他一些方法相比，这并不是那么糟糕。没有完全不同的方法可以实现这一目标。

唯一的替代方案（我认为你应该认真考虑）是使ChildBase和ParentBase非泛型，并在必要时使用强制转换。泛型被引入该语言，以帮助程序员编写正确的，类型安全的程序。当你的类之间有复杂或循环的关系时，弄清楚如何正确使用泛型变得如此困难和耗时，使用它们的好处就不存在了。

Answer 2

我花了一些时间来分析您所拥有的东西，但我并没有真正发现问题所在。您的定义似乎很好用。这到底是怎么一团糟？

将您需要的内容扩展到像这样的更具体的内容：

abstract class Child<T extends Child<T>> {

    private final Parent<T> parent;


    protected Child(Parent<T> parent) {
        this.parent = parent;
    }

    Parent<T> getParent() {
        return this.parent;
    }
}

abstract class Parent<T extends Child> {

    private final LinkedList<T> children = new LinkedList<>();

    void addChild(T child) {
        this.children.add(child);
    }

    List<? extends T> getChildren() {
        return Collections.unmodifiableList(this.children);
    }
}

我可以很容易地代表您想表达的想法：

class Daedalus extends Parent<Icarus> { }

class Icarus extends Child<Icarus> {

    public Icarus(Parent<Icarus> parent) {
        super(parent);
    }

}

然后做

Daedalus parent = new Daedalus();
Icarus child = new Icarus(parent);
parent.addChild(child);
for(Icarus aChild : parent.getChildren()) {
    //do something with aChild
}

我一点也不觉得这很混乱，从您的问题来看，这对我来说也不是显而易见的。

使用List <！ - ？ - >成员定义抽象泛型类

2 个答案: