Nested erstreckt sich in Generika

Question

Ich habe drei Klassen:

class ClassR {} 
class ClassA<T extends ClassR>{}  
class ClassB<E extends ClassA<T extends ClassR>> extends ClassA<T> { 
    void foo(T param) { 
    } 

    void bar(E param) { 
    } 
} 

Die dritte Klasse nicht kompilieren, wenn ich es ändern zu

class ClassB<E extends ClassA<T>, T extends ClassR> extends ClassA<T> { 
    void foo(T bar) { 
    } 

    void bar(E param) { 
    } 
} 

Gibt es eine Möglichkeit nur E-Parameter zu halten, ich übergeben müssen beim Erstellen von ClassB und T wird abgeleitet? Zum Beispiel wäre es zweckmäßig sein, zu verwenden:

new ClassB<ClassA<ClassR>>() 

statt:

new ClassB<ClassA<ClassR>, ClassR>() 

Answer 1

Nicht sicher, ob dies die Antwort ist, dass Sie wollen, aber sicher die einfachste Version lautet:

class ClassR { 
} 

class ClassA<T extends ClassR> { 
} 

class ClassB<T extends ClassR> extends ClassA<T> { 

    void foo(T bar) { 
    } 
} 

public void test() { 
    ClassB<ClassR> classB = new ClassB<>(); 
} 

Answer 2

Dieser noch einfachere Ansatz könnte für Sie funktionieren:

class ClassR {} 
class ClassA<T extends ClassR>{}  

class ClassB<T extends ClassR> extends ClassA<T> { 
    void foo(T bar) { 
    } 

    void bar(ClassA<T> param) { 
    } 
} 

Und Nutzung umgeht dann jeder Verweis auf ClassA werden:

class SubR extends ClassR {} 

ClassB<SubR> obj = new ClassB<SubR>(); 

Answer 3

Als Typen E erstreckt ClassA Sie sicher die ClassA Typparameter in ihrer Erklärung weglassen.
Korrekter ClassA Typ-Parameter wird im zweiten Parameter auf ClassB erzwungen.
Code unten zur Veranschaulichung Siehe:

class ClassB<E extends ClassA, T extends ClassR> extends ClassA<T> { 

    private ClassA ob; 

    public ClassB(E e, T t) { 
    super(t); 
    ob = e; 
    } 

} 

Nutzungs Beispiel:

class ClassR { 
    public ClassR() {}; 
} 

class ClassS extends ClassR { 
    private int x; 
    public ClassS(int x) { 
    super(); 
    this.x = x; 
    } 
} 

public static void test() { 
    ClassS data1 = new ClassS(1); 
    ClassB <ClassB, ClassS> first = new ClassB<>(null, data1); 
    ClassS data2 = new ClassS(2); 
    ClassB <ClassB, ClassS> second = new ClassB<>(first, data2); 
}