casting Collection <SomeClass> alla raccolta <SomeSuperClass>

Question

Sono sicuro che a questa domanda è stata data risposta in precedenza, ma non riesco davvero a trovarla.

Ho una classe java SomeClass e una classe astratta SomeSuperClass. SomeClass estende SomeSuperClass.

Un altro metodo astratto ha un metodo che restituisce un valore Collection<SomeSuperClass>. In una classe di implementazione, ho un Collection<SomeClass> myCollection

Capisco che non posso tornare myCollection, perché Collection<SomeClass> non eredita da Collection<SomeSuperClass>. Tuttavia, so che tutto in myCollection è un SomeSuperClass perché, dopo tutto, sono gli oggetti SomeClass che si estendono SomeSuperClass.

Come posso fare questo lavoro?

I.e. Voglio

public class A 
{ 
    private Collection<SomeClass> myCollection; 

    public Collection<SomeSuperClass> getCollection() 
    { 
    return myCollection; //compile error! 
    } 
} 

L'unico modo che ho trovato è colata attraverso un tipo non generico e ottenere avvisi incontrollati e quant'altro. Ci deve essere un modo più elegante, però? Ritengo che anche usando Collections.checkedSet() e gli amici non siano necessari, dal momento che è staticamente certo che la collezione restituita contiene solo oggetti SomeClass (questo non sarebbe il caso del downcasting invece del upcasting, ma non è quello che sto facendo). Cosa mi manca?

Grazie!

Answer 1

Non è possibile farlo. Avete una collezione <SomeClass> e desidera restituire un insieme <SuperClass>

Ora immaginate che qualcuno ha Collezione tornato - e tenta di inserire un diversa sottoclasse di SuperClass, SomeOtherClass. Questo dovrebbe essere consentito sulla vostra collezione SuperClass - ma non può perché è in realtà una raccolta <SomeClass>, all'insaputa di tutti, ma il membro privato di A.

Answer 2

Una collezione di sottotipo non è sostituibile per SuperTipo.

Answer 3

Non so perché; forse qualcun altro può spiegarlo; ma funziona se si fa:

public abstract class SomeSuperClass<E> { 
    abstract public Collection<SomeSuperClass<E>> getCollection(); 
} 

e:

public class Someclass extends SomeSuperClass { 
    @Override 
    public Collection<Someclass> getCollection() { 
     // TODO Auto-generated method stub 
     return null; 
    } 
} 

Answer 4

forse, si dovrebbe fare qualche soluzione alternativa.

ad esempio, dovresti creare un "HolderClass" con estensione generica, e poi sarai in grado di mettere in condizione meteo il tuo SomeClass, superare il tuo SomeSuperClass.

un'occhiata:

public class HolderClass<E extends SomeSuperClass> { 

    private final Collection<E> myClass; 

    public HolderClass() { 
     myClass = new ArrayList<E>(); 
    } 

    public void putSomeClass(final E clazz) { 
     myClass.add(clazz); 
    } 

    public Collection<E> getMyClasses() { 
     return myClass; 
    } 

} 

e si può effettuare la raccolta in questo modo:

HolderClass<SomeSuperClass> holderClass = new HolderClass<SomeSuperClass>(); 
holderClass.putSomeClass(new SomeClass()); 
holderClass.putSomeClass(new SomeSuperClass()); 

e ora, quando si effettua chiamata a getMyClasses(), si otterrà collezione di SomeSuperClasses

Answer 5

.NET 4.0 introduce covarianza e controvarianza ai generici:

http://msdn.microsoft.com/en-us/library/dd799517(VS.100).aspx

Answer 6

Collection<? extends SomeSuperClass> non farà quello che vuoi?

Answer 7

Se si crea una nuova collezione di tipo corretto è possibile popolare utilizzando la vecchia collezione

public Collection<SomeSuperClass> getCollection() 
{ 
    return new ArrayList<SomeSuperClass>(myCollection); 
} 

Answer 8

Sulla base della risposta superiore data a questa domanda: How do you cast a List of supertypes to a List of subtypes?

Io non credo che sia possibile fare

Collection<SomeSuperType> variable = 
        (Collection<SomeSuperType>)(Collection<?>) collectionOfSomeType; 

A scapito di un avviso "non controllato". Alla domanda collegata, è stata espressa preoccupazione circa la "scelleratezza" di questa risposta a causa della mancanza di sicurezza del tipo. Tuttavia, nel contesto di questa domanda (vale a dire una raccolta di sottotipi in una raccolta dei loro supertipi) non vedo problemi o possibili ClassCastExceptions. E in ogni caso, funziona abbastanza bene.

Answer 9

Java 8 ora offre un modo più ordinato di farlo utilizzando lambdas: è possibile utilizzare le funzioni map() and collect() per trasmettere gli oggetti alla classe super. Una soluzione per il tuo esempio sarebbe simile a questa:

public class A 
{ 
    private Collection<SomeClass> myCollection; 

    public Collection<SomeSuperClass> getCollection() 
    { 
     return myCollection.stream().map(x -> (SomeSuperClass) x).collect(Collectors.toList()); 
    } 
} 

È inoltre possibile utilizzare altri Collectors se necessario.

Answer 10

Sì, possiamo!

class A {@Override 
public String toString() 
{ 

    return "A"; 
} }; 
class B extends A { 
    @Override 
    public String toString() 
    {  
    return "B"; 
    } 
}; 
List<A> l1 = new ArrayList<A>(); 
l1.add(new A()); 
List<B> l2 = null; 
l2 = (List<B>)(List<? extends A>)l1; 
l2.add(new B()); 

System.out.println(Arrays.toString(l2.toArray())); 

effettuate alcune prove