colección de fundición <SomeClass> para Colección <SomeSuperClass>

Question

Estoy seguro de que esto ha sido respondido antes, pero realmente no lo puedo encontrar.

Tengo una clase java SomeClass y una clase abstracta SomeSuperClass. SomeClass extiende SomeSuperClass.

Otro método abstracto tiene un método que devuelve Collection<SomeSuperClass>. En una clase de implementación, tengo un Collection<SomeClass> myCollection

entiendo que no puedo acaba de regresar myCollection, porque Collection<SomeClass> no hereda de Collection<SomeSuperClass>. Sin embargo, sé que todo en myCollection es SomeSuperClass porque después de todo, son SomeClass objetos que extienden SomeSuperClass.

¿Cómo puedo hacer esto?

I.e. Quiero

public class A 
{ 
    private Collection<SomeClass> myCollection; 

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

La única forma que he encontrado es la fundición a través de un tipo no genérico y conseguir advertencias y todo eso sin marcar. Sin embargo, debe haber una manera más elegante? Siento que también usar Collections.checkedSet() y amigos no es necesario, ya que es estáticamente cierto que la colección devuelta solo contiene objetos SomeClass (este no sería el caso cuando downcasting en lugar de upcasting, pero eso no es lo que estoy haciendo). ¿Qué me estoy perdiendo?

Gracias!

Answer 1

No puede hacer esto. Tiene una colección <SomeClass> y desea devolver una colección <SuperClass>

Ahora imagina que alguien tiene su cobro devuelto - y se intenta insertar un diferente subclase de SuperClass, SomeOtherClass. Esto se debe permitir en su colección SuperClass - pero no puede porque es en realidad una colección <SomeClass>, sin que nadie más que el miembro privada de A.

Answer 2

Una colección del subtipo no es sustituible de supertipo.

Answer 3

No estoy seguro de por qué; tal vez alguien más pueda explicar esto; pero funciona si lo hace:

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

y:

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

Answer 4

tal vez, usted debe hacer algunas solución.

por ejemplo, debe hacer un poco de "HolderClass" con una extensión genérica, y entonces podrá ponerle tiempo a su SomeClass, capear su SomeSuperClass.

echar un vistazo:

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

} 

y usted puede hacer la colección de esta manera:

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

y ahora, cuando se hace la llamada a getMyClasses(), obtendrá colección de SomeSuperClasses

Answer 5

.NET 4.0 introduce covarianza y contravarianza a los genéricos:

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

Answer 6

¿Collection<? extends SomeSuperClass> no hará lo que usted quiere?

Answer 7

Si crea una nueva colección del tipo correcto puede rellenarlo utilizando la antigua colección

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

Answer 8

Sobre la base de la respuesta superior dado a esta pregunta: ¿ How do you cast a List of supertypes to a List of subtypes?

yo creo que es posible hacer

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

A expensas de una advertencia de "desmarcado". En la pregunta vinculada, se ha expresado preocupación sobre el "hackiness" de esta respuesta debido a la falta de seguridad de tipo. Sin embargo, en el contexto de esta pregunta (es decir, fundir una colección de subtipos en una colección de sus supertipos) no veo problemas ni posibles ClassCastExceptions. Y en cualquier caso, funciona bastante bien.

Answer 9

Java 8 ahora ofrece una manera más clara de hacerlo usando lambdas: puede usar las funciones map() and collect() para convertir los objetos a su súper clase. Una solución para su ejemplo sería el siguiente:

public class A 
{ 
    private Collection<SomeClass> myCollection; 

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

También puede utilizar otra Collectors si es necesario.

Answer 10

Sí, podemos!

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

favor probarlo