Enum <? estende l'interfaccia>

Question

sto cercando di avere una collezione di enumerazioni che si estendono un'interfaccia comune, in modo da qualcosa come:

interface Fooable 
{ 
    void someCommonMethod(); 
} 

enum E1 implements Fooable 
{ 
    // some enumuerations and a definition for someCommonMethod() 
} 

enum E2 implements Fooable 
{ 
    // some different enumerations and a different definition for someCommonMethod() 
} 

e poi fare uso di questo altrove applicando sia che una variabile è un Enum e implementa l'interfaccia. Quindi, qualcosa sulla falsariga di ..

bar(Enum<? extends Fooable> fe) 
{ 
    fe.ordinal(); 
    fe.someCommonMethod(); 
} 

Tuttavia, finora mi sembra di avere a gettare fe al fine di trattare come implementando l'interfaccia, vale a dire,

bar(Enum<? extends Fooable> fe) 
{ 
    fe.ordinal(); 
    ((Fooable)fe).someCommonMethod(); 
} 

e mentre questo dovrebbe essere sicuro ... sembra non ottimale e potrei trascurare qualcosa. Certo che se provo a passare il param come Fooable, finisco col cast per considerarlo un Enum e non solo questo non guadagno non sono nemmeno sicuro. Vedere seguente:

bar(Fooable fe) 
{ 
    // potentially unsafe cast! 
    ((Enum<?>)fe).ordinal(); 
    fe.someCommonMethod(); 
} 

C'è qualcosa che sto affaccia o è il

Enum<? extends Fooable> 

quanto di più vicino ad una soluzione 'buona', come vado a prendere?

Sono relativamente nuovo a Java e sto ancora cercando di usarlo come C o C++ quindi se lo sto trattando come un martello invece di una sega o trascurando qualcosa di stupidamente semplice sentiti libero di indicarlo :)

Answer 1

una possibilità che si ha È necessario aggiungere uno qualsiasi dei metodi di Enum di cui si ha bisogno su Fooable o creare una nuova interfaccia che estenda Fooable e aggiunga i metodi Enum necessari.

Esempio:

interface Fooable { 
    void someCommonMethod(); 
} 

interface FooableEnum extends Fooable { 
    int ordinal(); 
} 

enum E1 implements FooableEnum { 
    // Implement someCommonMethod. 
    // ordinal() is already implemented by default. 
} 

Una volta fatto questo è possibile utilizzare FooableEnum come il tipo di parametro nella vostra firma del metodo e non preoccuparsi di una qualsiasi delle cose generiche.

Answer 2

Ciò significa che T si estende Enum e implementa Fooable:

<T extends Enum<T> & Fooable> 

così il metodo può essere scritta come:

<T extends Enum<T> & Fooable> void bar(T fe) { 
    fe.ordinal(); 
    fe.someCommonMethod(); 
}