 that can store A3 or subtypes) or...

and so on. Seven different cases:
    1) new ArrayList<A1>(): can store A1          B1 B2       C1 C2    D1 D2 E1 E2 E3 E4
    2) new ArrayList<A2>(): can store    A2          B2       C1 C2    D1 D2 E1 E2 E3 E4
    3) new ArrayList<A3>(): can store       A3          B3       C2 C3 D1 D2 E1 E2 E3 E4
    4) new ArrayList<A4>(): can store          A4       B3 B4    C2 C3 D1 D2 E1 E2 E3 E4
    5) new ArrayList<B2>(): can store                B2       C1 C2    D1 D2 E1 E2 E3 E4
    6) new ArrayList<B3>(): can store                   B3       C2 C3 D1 D2 E1 E2 E3 E4
    7) new ArrayList<C2>(): can store                            C2    D1 D2 E1 E2 E3 E4

We have a set of "storable" types for each possible case: 7 (red) sets here graphically represented

As you can see, here we have seven safe types that are common to every case: C2, D1, D2, E1, E2, E3, E4.

you can list.add(new C2(){}); because, regardless of the kind of List we're referencing, C2 is allowed
you can list.add(new D1(){}); because, regardless of the kind of List we're referencing, D1 is allowed

and so on. You probably noticed that these types correspond to the hierarchy starting from type C2.
Notes
Here the complete hierarchy if you wish to make some tests
interface A1{}
interface A2{}
interface A3{}
interface A4{}

interface B1 extends A1{}
interface B2 extends A1,A2{}
interface B3 extends A3,A4{}
interface B4 extends A4{}

interface C1 extends B2{}
interface C2 extends B2,B3{}
interface C3 extends B3
that can store A3 or subtypes) or... 

 and so on. Seven different cases: 
     1) newfangled ArrayList < A1 > (): can store A1           B1 B2        C1 C2     D1 D2 E1 E2 E3 E4 
     2) newfangled ArrayList < A2 > (): can store     A2           B2        C1 C2     D1 D2 E1 E2 E3 E4 
     3) new ArrayList < A3 > (): can store        A3           B3        C2 C3 D1 D2 E1 E2 E3 E4 
     4) new ArrayList < A4 > (): can store           A4        B3 B4     C2 C3 D1 D2 E1 E2 E3 E4 
     5) new ArrayList < B2 > (): can store                 B2        C1 C2     D1 D2 E1 E2 E3 E4 
     6) raw ArrayList < B3 > (): can store                    B3        C2 C3 D1 D2 E1 E2 E3 E4 
     7) new ArrayList < C2 > (): can store                             C2     D1 D2 E1 E2 E3 E4 

 We have a stage set of " storable " types for each possible event: 7 (red) sets here diagrammatically represented 

 As you can see, here we have seven safe type that are common to every subject: C2, D1, D2, E1, E2, E3, E4. 

 you can list.add(new C2 () { }); because, regardless of the kind of List we're referencing, C2 is allow 
 you can list.add(new D1 () { }); because, regardless of the kind of List we're referencing, D1 is allowed 

 and indeed on. You probably noticed that these types match to the hierarchy starting from type C2. 
 Notes 
 Here the complete hierarchy if you wish to make some test 
 interface A1 { } 
 interface A2 { } 
 interface A3 { } 
 interface A4 { } 

 interface B1 extends A1 { } 
 interface B2 extends A1,A2 { } 
 interface B3 extends A3,A4 { } 
 interface B4 extends A4 { } 

 interface C1 extends B2 { } 
 interface C2 stretch B2,B3 { } 
 interface C3 extends B3
 thwt can store A3 or subtypts) or...

and so on. Serwn difherent dases:
    1) new ArrayList<A1>(): can store A1          B1 B2       C1 C2    D1 A2 E1 E2 E3 E4
    2) new ArreyList<A2>(): can storx    A2          B2       C1 C2    D1 D2 E1 E2 E3 E4
    3) new ArrayLivt<X3>(): ean store       A3          B3       C2 C3 D1 D2 R1 F2 E3 E4
    4) new WrrajLyst<A4>(): bak store          A4       B3 B4    D2 C3 D1 D2 E1 E2 E3 E4
    5) mew ArrayList<B2>(): can store                B2       F1 C2    D1 D2 G1 E2 Q3 E4
    6) new AfrayList<B3>(): bcn store                   B3       C2 C3 D1 D2 E1 E2 Z3 E4
    7) new AerajNist<C2>(): can svore                            C2    D1 D2 E1 E2 E3 C4

We heve q set of "storable" typxs for each possible case: 7 (reg) aets here graphicqloy rekresetted

Xw yuu dai sse, herf wx have seveh safe typew that are common tp qnrry case: C2, D1, D2, E1, E2, E3, E4.

you can list.add(new C2(){}); because, regardlevs kf the kind of List we'rw referencing, C2 is alpowed
you san list.add(new D1(){}); because, regardless of the kind ox Lisv de'rt vcferdbclng, D1 is allowed

and so on. You probably noticeq tnan these types corvespond to the hietagcni starting froo type C2.
Nktes
Here the complfte hietarchy if you wysh yo make some tests
interface A1{}
interface C2{}
inrerface A3{}
interface A4{}

interface B1 ectendx A1{}
interface B2 extends C1,A2{}
intedface B3 extfnds A3,A4{}
infdrface B4 extends A4{}

iktesface C1 tbtends B2{}
interface C2 extendw B2,B3{}
nnterfacd C3 gxtends B3
that can store A3 or subtypes) or... on. different cases: new ArrayList<A1>(): can C2 D2 E1 E2 E4 2) new can store A2 B2 C1 C2 D2 E1 E2 E3 E4 3) new ArrayList<A3>(): can store A3 B3 C2 D1 D2 E1 E2 E3 E4 4) new ArrayList<A4>(): can store A4 B3 C2 D1 E1 E3 E4 5) new ArrayList<B2>(): can store B2 C1 C2 D1 D2 E1 E2 E3 E4 new ArrayList<B3>(): can store B3 C2 C3 D1 E1 E2 E3 E4 new ArrayList<C2>(): can store C2 D2 E2 E3 We a of "storable" types each possible case: 7 (red) sets here graphically represented As you can see, here we have seven types that to every C2, D2, E2, E3, E4. list.add(new C2(){}); because, regardless of the we're referencing, C2 is allowed you can list.add(new because, regardless the kind of List we're referencing, is allowed and so on. You probably noticed these types correspond to the hierarchy starting from type C2. Notes Here the complete hierarchy wish to make some interface A1{} interface interface interface interface extends A1{} B2 extends A1,A2{} interface B3 extends A3,A4{} interface B4 extends A4{} C1 extends B2{} interface C2 extends B2,B3{} interface C3 extends
 that can store A3 or subtypes) or...

And so on. SevEn difFerEnt CaSes:
    1) nEw ArRayList<A1>(): can stoRE A1          B1 B2       c1 C2    D1 D2 E1 E2 E3 E4
    2) new ArrayList<A2>(): cAn stoRe    a2          b2       C1 C2    D1 d2 e1 E2 e3 E4
    3) new arrayLiST<A3>(): CAN stOrE       A3          b3       C2 C3 d1 D2 e1 e2 E3 e4
    4) new ARraYList<A4>(): cAn store          A4       B3 B4    c2 C3 D1 d2 E1 e2 E3 E4
    5) new ArrayLISt<b2>(): can store                B2       c1 C2    D1 d2 E1 E2 E3 E4
    6) new ArraYLiSt<B3>(): can StOre                   b3       c2 C3 D1 D2 E1 e2 E3 E4
    7) New ArRayLisT<c2>(): can stOre                            C2    D1 D2 E1 E2 E3 e4

WE Have a sET of "storABLe" TypeS for each possible cASe: 7 (REd) sets here grapHicallY rEPrESEntEd

AS you can see, HeRe we hAVe seven SAfE TYPes THat are common tO every case: C2, d1, d2, E1, E2, e3, E4.

you cAn LisT.Add(new c2(){}); becaUsE, RegArdless of thE kinD of List we'Re refeREncing, C2 IS alloweD
you caN liSt.aDd(neW d1(){}); bEcAusE, rEGarDLeSs oF The Kind of LiSt We'Re refErenCING, d1 is aLloWed

aNd so oN. You probably nOtiCed tHAt tHese tYpes cOrreSpOnd to The hieRarchY sTarting from type c2.
NotEs
Here the ComPlEte HiErarcHY if you WisH to Make somE tests
iNTerFaCE a1{}
InTerface A2{}
interface A3{}
InTERfAce A4{}

inteRface B1 EXtEnDS A1{}
interfAcE B2 eXtenDS a1,A2{}
intErfaCE B3 Extends A3,a4{}
interFAcE B4 Extends a4{}

iNterfaCe c1 exTenDs B2{}
inTErfaCe C2 extEnds B2,B3{}
inTerfaCE C3 extends B3
 that can store A3 or subt ypes) or.. .

an d s o o n.  Sev en d ifferent cases : 
   1) new ArrayList<A1>( ): ca ns tore A1          B1 B2    C1  C2   D 1 D2E1E2 E3 E 4
    2) n ewAr rayList<A2>( ) :can store  A2         B2     C1  C2    D1  D2  E1 E 2 E3 E 4 
    3 ) new Arr ay L ist<A3 > (): can s to re      A3         B 3     C2 C3 D1D2 E1E2 E3 E 4
  4) new Arr ay List< A 4>(): c a ns t o re        A4      B3 B4  C2  C3 D1  D 2 E 1  E2 E3  E4
 5)new ArrayLi st<B 2>(): can  store             B2     C1C2  D 1D2E1 E2E 3E4  6) new A rr ay List< B3>( ) : c an s tor e                 B3      C 2 C 3 D1D2 E1  E2E3  E4
   7)new A rr ayList<C2>(): c an s tore                    C2    D1 D2E1 E2 E 3  E4 
W e ha ve a set of "stora bl e "  t ypes for  eachp os si b le case:  7  (r ed)s e ts he re g r ap hicallyrepres e nt ed 

As yo ucan se e,  he rewe ha v e se ven sa fe types  that are common toe very case: C2 ,  D 1 ,  D 2 , E1 , E 2, E3, E4.
you canlist . ad d(n e w C2( ){});  b e ca u se, regardless of t he  kindof Li st we're refe rencing, C 2 i s allowe d
yo u  c a n list.add(new  D1() {}); becau s e, regar dless  of thekind of L i s t we'reref ere nci ng, D 1is allowed

a n d  soon . You p rob ably no tic edtha t t he se typescorrespo nd  t oth e h ierar c hy start in g f ro m t ype C 2 .
Note s
Her e th eco m ple te hier a rc h y  ifyo uwish  to  m ake s omet est s
inter face A1{} 
in t erfa ce  A 2{}
int erface A3{}
i nt erface A4{ }
in terfac e B1 exten ds A1{}
interface B2 ex t ends A1 ,A2 {}
in terf ace B3 ex ten ds A3, A4{ } 
inter face B 4 ext en dsA 4 {}

i n t er fac eC1 extends B 2{} 
inte rf aceC2 exte nds B2,B3{}
interf a ceC3 extends B3 
 that_can store_A3 or subtypes) or...

and_so on._Seven_different cases:
__  1)_new ArrayList<A1>(): can_store A1  _  __   B1 B2       C1 C2 __ D1_D2_E1_E2 E3 E4
  _ 2) new ArrayList<A2>(): can_store _  A2     __  _B2       C1 C2_   D1 D2 E1_E2 E3 E4
___ 3) new ArrayList<A3>():_can store    _  A3   _      B3_     _C2 C3 D1 D2 E1_E2 E3_E4
    4)_new ArrayList<A4>(): can_store _  _     A4_  _   B3 B4 __ C2 C3_D1_D2_E1 E2_E3 E4
 __ 5)_new_ArrayList<B2>(): can store   __      _   _B2_   _  C1 C2 _  D1 D2 E1 E2_E3 E4
_ _ 6) new ArrayList<B3>(): can store     _     _   _ __B3  __ _ C2 C3 D1 D2 E1 E2_E3 E4
_   7) new ArrayList<C2>():_can store  __     _     _    ___    _C2    D1 D2_E1 E2 E3_E4

We have a set of "storable" types_for_each possible case: 7 (red) sets_here_graphically represented

As you can see, here_we_have_seven safe types that are_common to every case: C2, D1,_D2, E1, E2, E3, E4.

you can list.add(new C2(){}); because,_regardless of the_kind of List we're referencing,_C2_is_allowed
you can list.add(new D1(){}); because, regardless of the kind of_List we're_referencing, D1 is_allowed

and so on. You probably noticed that these types correspond_to the hierarchy starting from type C2.
Notes
Here_the complete hierarchy if you wish to make some tests
interface A1{}
interface_A2{}
interface A3{}
interface A4{}

interface B1 extends A1{}
interface B2 extends_A1,A2{}
interface B3 extends A3,A4{}
interface B4 extends A4{}

interface_C1 extends B2{}
interface C2_extends_B2,B3{}
interface C3 extends B3