Java generici: Illegal di riferimento in avanti

Question

Dato un'interfaccia generica

interface Foo<A, B> { } 

Voglio scrivere un'implementazione che richiede una di essere una sottoclasse di B. Quindi voglio fare

class Bar<A, B super A> implements Foo<A, B> { } 
// --> Syntax error 

o

class Bar<A extends B, B> implements Foo<A, B> { } 
// --> illegal forward reference 

Ma l'unica soluzione che sembra funzionare è questo:

class Bar<B, A extends B> implements Foo<A, B> { } 

che è un po 'brutto, perché inverte l'ordine dei parametri generici.
Esistono soluzioni o soluzioni alternative a questo problema?

Answer 1

Poiché ciò non è possibile in Java, provare a pensare a Bar<B, A extends B> in modo diverso.

Quando si dichiara una variabile per Bar, si specifica prima la classe padre e poi la classe figlio. È così che funziona Bar. Non pensarlo come indietro - pensalo come avanti. Il genitore dovrebbe essere naturalmente specificato prima del bambino. Questa relazione aggiuntiva che hai aggiunto è ciò che guida l'ordine dei parametri, non l'interfaccia sottostante.

Answer 2

Dopo aver visto questa domanda, ho passato un po 'a provare alcune tecniche diverse che pensavo potessero funzionare. Ad esempio, la creazione di un'interfaccia generica ISuper<B,A extends B> e il successivo utilizzo di Bar<A,B> implements ISuper<B,A> (e una tecnica simile con una sottoclasse e un'estensione anziché le implementazioni), ma ciò comporta un errore di tipo, Bar.java:1: type parameter A is not within its bound. Allo stesso modo, ho provato a creare un metodo private <A extends B> Bar<A,B> foo() { return this; }; e chiamarlo dal costruttore, ma questo si traduce semplicemente nel divertente messaggio di errore Bar.java:2: incompatible types found : Bar<A,B> required: Bar<A,B>

Quindi, penso che, sfortunatamente, la risposta sia no. Ovviamente, non è la risposta che speravi, ma sembra che la risposta corretta sia che questo non è possibile.

Answer 3

È stato già rilevato che non esiste né una soluzione né una soluzione piacevole. Ecco cosa ho finalmente fatto. Funziona solo per il mio caso speciale, ma puoi prenderlo come ispirazione se incontri problemi simili. (Ciò spiega anche il motivo per cui mi sono imbattuto in questo problema)

Prima di tutto, v'è questa classe (che mostra solo l'interfaccia in questione):

class Pipe<Input, Output> { 

    boolean hasNext(); 

    Input getNext(); 

    void setNext(Output o); 

} 

L'interfaccia Foo è in realtà

interface Processor<Input, Output> { 

    process(Pipe<Input, Output> p); 

} 

e la classe Bar dovrebbe funzionare in questo modo

class JustCopyIt<Input, Output> implements Processor<Input, Output> { 

    process(Pipe<Input, Output> p) { 
     while (p.hasNext()) p.setNext(p.getNext()); 
    } 

} 

Il modo più semplice sarebbe quello di trasmettere valori come questo: p.setNext((Output) p.getNext()). Ma questo è male in quanto consentirebbe di creare un'istanza di JustCopyIt<Integer, String>. Chiamare questo oggetto fallirebbe misteriosamente ad un certo punto, ma non nel punto in cui viene fatto l'errore effettivo.

Fare anche class JustCopyIt<Type> implements Processor<Type, Type> non funzionerebbe anche qui, perché quindi non sono in grado di elaborare un Pipe<String, Object>.

Così che alla fine ho fatto è stato per modificare l'interfaccia a questo:

interface Processor<Input, Output> { 

    process(Pipe<? extends Input, ? super Output> p); 

} 

In questo modo, un JustCopyIt<List> è in grado di elaborare un Pipe<ArrayList, Collection>.

Mentre questa tecnica sembra essere l'unica soluzione valida, è ancora male perché 1) funziona solo per questo caso speciale, 2) mi ha richiesto di cambiare l'interfaccia (che non è sempre possibile) e 3) ha fatto il codice degli altri processori brutto.

Edit:
lettura Keiths risposta ancora una volta mi ha ispirato per un'altra soluzione:.

public abstract class Bar<A, B> implements Foo<A, B> { 

    public static <B, A extends B> Bar<A, B> newInstance() { 
     return new BarImpl<B, A>(); 
    } 

    private static class BarImpl<B, A extends B> extends Bar<A, B> { 
     // code goes here 
    } 

} 

// clean code without visible reversed parameters 
Bar<Integer, Object> bar1 = Bar.newInstance(); 
Bar<Object, Integer> bar2 = Bar.newInstance(); // <- compile error