接口，繼承和子類型

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>，其遞歸地執行所述第二接口布雷茲札克作爲內部類這樣的：ThisIter implements BIter<Something,ThisIter,SomethingElse>

兩個類的具有這樣的功能稱爲public ThisIter giveIter();應返回內部類的實例（每個內部類的有一個類似的函數，它也返回一個新的實例，但是具有不同的參數）。

是否可以將ClassB作爲ClassA的子類型實現？ （鑑於泛型類型是相同的，如ClassA<MyString>和ClassB<MyString, somethingelse>）

我似乎無法做到這一點，因爲ThisIter的實例和爲此返回類型的giveIter（）是不兼容的。

一般問到，子接口（n）是接口本身實現的子類型的實現嗎？

伊特拉

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

我們不能重寫內部類。閱讀約內部類可以重寫。

問：是否可以將ClassB作爲ClassA的子類型實現？

答：是的，您需要爲您的ClassB.getIter()選擇不同的名稱。否則，它會抱怨重寫的方法有不同的返回類型或其他東西。實際上，你並不打算重寫它，但編譯器無法知道。因此，您需要爲它選擇其他名稱。

Q.一般問到的是子接口（n）的實現是否是接口本身實現的子類型？

答：不，在這種情況下，它將是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(); 
    } 
}