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的子类型？（鉴于泛型类型相同，例如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> {}

ClassA的：

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);
    }
}

ClassB的：

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的子类型？

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

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

一个。不，在这种情况下，它将是两个不同的类层次结构。一个从上到下，interfaceA - ＆gt; interfaceB - ＆gt; classD，和另一个接口A - ＆gt; 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();
    }
}

接口，继承和子类型

3 个答案: