¿Es posible crear colecciones de Java seguras de tipo cuyos miembros simplemente implementen varias interfaces?

Question

Si tengo:

interface A{ void a(); } 
interface B{ void b(); } 

puedo hava un método genérico de esta manera:

class C { 
    <T extends A & B> void c(T t) { 
     t.a(); 
     t.b(); 
    } 
} 

pero no puedo hava una colección genérica como esto:

class D{ 
    List<? extends A & B> l; 
} 

que sé que podría hacer una interfaz E vacía que amplíe tanto A como B, y que tenga una Lista que contenga E ... pero preferiría dejar mis clases marcadas con solo A y B, y no tener que tener una E. Esto es aún más problemático cuando hay muchas más A y B que se pueden combinar de 2 maneras.

Prefiero ser capaz de definir un tipo sobre la marcha, como una unión de interfaces, y hacer que las colecciones reconozcan objetos que implementan todas las interfaces como instancias de ese tipo.

¿Hay alguna manera de hacer esto en Java? Estoy abierto a cualquier tipo de trabajo o pirateo en este punto para evitar crear una nueva interfaz y etiquetar mis clases con ella, solo para que puedan vivir juntas en una colección. O, si alguien puede aclararme por qué esto es imposible, eso sería igualmente apreciado.

Answer 1

public class Foo<T extends A & B> { 
    private List<T> list; 
    //getters, setters, etc. 
} 

Answer 2

Como Jeffrey también dijo que de alguna manera, tiene que parametrizar la clase D:

class D<T extends A & B> { 
    List<T> l; 

    /** 
    * this is just a method for the sake of example 
    */ 
    public T getSomeMember() { 
     return l.iterator().next(); 
    } 
} 

esta manera usted está aplazando su elección del tipo real T al método que en realidad insntatiates D. Si esa información no está disponible incluso en ese momento se le tiene que parametrizar ese método también con <T extends A & B>:

private <T extends A & B> 
void doSomething() { 
    D<T> d = new D<T>(); 

    T v1 = d.getSomeMember(); 
    A v2 = d.getSomeMember(); 
    B v3 = d.getSomeMember(); 
} 

Si hay un campo de tipo D de alguna clase, entonces esa clase debe conocer el tipo real que extends A & B , o se parametrizará si no lo hace. En principio, propagas el parámetro de tipo hasta que conozcas el tipo real.

Tenga en cuenta que es probable que este proceso sea inmanejable para códigos grandes. También puede dar como resultado un código feo, pero por supuesto que depende de su concepción de la estética.