接口、继承和子类型

Question

我有以下 JAVA 乱七八糟的东西，我不太清楚：

具有两个泛型 A 和 B 的泛型接口，例如 AIter<A,B>

另一个泛型接口和一个额外的泛型类型 C，像这样：BIter<A,B,C> extends AIter<A,B>

一个泛型类ClassA<D>，它递归地将第一个接口AIter实现为一个内部类，如下所示：ThisIter implements AIter<Something,ThisIter>

另一个泛型类ClassB<D,E>，它递归地将第二个接口 BIter 实现为内部类，如下所示：ThisIter implements BIter<Something,ThisIter,SomethingElse>

这两个类都有一个名为 public ThisIter giveIter(); 的函数，它应该返回内部类的一个实例（每个内部类都有一个类似的函数，它也返回一个自身的新实例，但参数不同）。

是否可以将 ClassB 实现为 ClassA 的子类型？ （假设泛型Types相同，如ClassA<MyString>和ClassB<MyString, somethingelse>）

我似乎无法实现，因为 ThisIter 的实例以及 giveIter() 的返回类型不兼容。

一般来说，子接口（n）的实现是接口本身实现的子类型吗？

IterA

public interface IterA<A,B> {}

IterB

public interface IterB<A,B,C> extends IterA<A,B> {}

A 类：

public class ClassA<L> {
    Node root;

    public ClassA() {
        root= new Node();
    }

    protected class Node {
       /*...*/
    }

    protected class Edge {
        /*...*/
        L varL;
    }

    protected class ThisIter implements IterA<Edge,ThisIter> {
    /*...*/
    }
    public IterA<Edge,ThisIter> assoc() {
        return new ThisIter(root);
    }
}

B 类：

public class ClassB<L,N> {
    Node root;

    public ClassB() {
        root= new Node();
    }

    protected class Node {
       /*...*/
       N varN;
    }

    protected class Edge {
        /*...*/
       L varL;
    }

    protected class ThisIter implements IterB<Edge,ThisIter,N> {
    /*...*/
    }
    public IterB<Edge,ThisIter,N> assoc() {
        return new ThisIter(root);
    }
}

Answer 1

我们不能覆盖内部类。阅读here 关于内部类可以被覆盖。

问。是否可以将 ClassB 实现为 ClassA 的子类型？

A.是的，您需要为您的ClassB.getIter() 选择一个不同的名称。否则，它会抱怨被覆盖的方法有不同的返回类型或其他东西。实际上，您并不打算覆盖它，但编译器无法知道。因此，您需要为其选择其他名称。

问。一般来说，子接口的实现（n）是否是接口本身实现的子类型？

A.不，在这种情况下，它将是 2 个不同的类层次结构。一个从上到下，interfaceA -> interfaceB -> classD，另一个 interfaceA -> classC。

Answer 2

重新考虑您的命名和代码分解，尤其是您的每个容器类中是否真的需要一个名为 node 和 edge 的类？

这是可编译的，类似于您的代码（据我了解其意图。）

    interface IterA<A,B> {}
    interface IterB<A,B,C> extends IterA<A,B> {}

    class ClassA<L> {
        NodeA root;
        public ClassA() { root= new NodeA(); }
        protected class NodeA { }
        protected class EdgeA { L varL; }
        protected class ThisIterA implements IterA<EdgeA, ThisIterA> { ThisIterA(NodeA root) { } }

        public IterA<? extends EdgeA, ? extends IterA> assoc() { return new ThisIterA(root); }
    }

    class ClassB<L,N> extends ClassA<L> {
        NodeB root;
        public ClassB() { root= new NodeB(); }
        protected class NodeB extends NodeA { N varN; }
        protected class EdgeB extends EdgeA { L varL; }
        protected class ThisIterB<EA extends EdgeA, TIA extends IterB> implements IterB<EA, TIA, N> { ThisIterB(NodeB root) { } }

        public IterB<EdgeB, IterB, N> assoc() { return new ThisIterB<EdgeB, IterB>(root); }
    }

这里已经很晚了，所以这是我的最后一个。祝你好运，晚安！

Answer 3

不确定这是否有帮助，但以下编译

interface AIter<A,B>{}
interface BIter<A,B,C,D extends A,E extends B > extends AIter<A,B>{}

class AClass{
    protected class Node {}
    protected class Edge {}

    public class ThisIter implements AIter<Node,Edge>{};

    public ThisIter getIter(){
        return new ThisIter();
    }
}

class BClass<N> extends AClass{
    protected class Node extends AClass.Node{}
    protected class Edge extends AClass.Edge{}

    public class ThisIter extends AClass.ThisIter implements BIter<AClass.Node,AClass.Edge, N, Node, Edge>{};

    @Override
    public ThisIter getIter(){
        return new ThisIter();
    }
}