2013-03-20 17 views
5

Come sappiamo che la classe Java enum:Come riutilizzare il codice in molteplici Enum

  1. estende implicitamente java.lang.Enum;
  2. non può estendersi da altre classi di enumerazione.

ho più classe enum, come di seguito:

enum ResourceState { 
    RUNNING, STOPPING,STARTTING;//... 
    void aMethod() { 
     // ... 
    } 
} 

enum ServiceState { 
    RUNNING, STOPPING,STARTTING,ERROR;//... 
    void aMethod() { 
     // ... 
    } 
} 

il metodo aMethod() in enum ResourceState e ServiceState è esattamente la stessa.

in OOP, se ResourceState e ServiceState non sono enum, dovrebbero astratto lo stesso metodo per una classe astratta super, come questo:

abstract class AbstractState{ 
    void aMethod() { 
     // ... 
    } 
} 

ma ResourceState è in grado di estende dal AbstractState, hai qualche idea di aggirare?

+0

Cosa vuoi dire 'esattamente la stessa cosa'? Non vi è alcun riferimento all'enum? In tal caso, è possibile estrarre la logica in un metodo statico. –

+0

Questo è quello che sto facendo ora, ma sto cercando una soluzione migliore – BlackJoker

risposta

3

Ah sì, questa limitazione mi ha morso un paio di volte. Fondamentalmente, succede quando non hai altro che il modello più banale su cui applichi l'enum.

Il modo migliore in cui ho trovato di aggirare questo era una classe di utilità con metodi statici che vengono chiamati dal tuo aMethod.

+0

Sì, quello è il modo migliore per ridurre al minimo il codice duplicato – BlackJoker

2

È possibile sostituire l'enum con il vecchio "SICURO tipo disegno del modello Enum":

public class ResourceState { 
    private ResourceState() { 
    } 

    public void aMethod() { .... } 

    public static ResourceState RUNNING = new ResourceState(); 
    public static ResourceState STOPPING = new ResourceState(); 
    .... 
} 

E poi estenderla e sovrascrivere aMethod se necessario.

+0

Sì, questo è un buon work-around – BlackJoker

4

Le enumerazioni non possono estendere altre classi, ma possono implementare interfacce. Così, un altro orientato agli oggetti approccio sarebbe quello di rendere i vostri enumerazioni implementano un'interfaccia comune e quindi utilizzare la delega ad una classe di supporto che fornisce il vero Implementazione:

public interface SomeInterface { 
    void aMethod(); 
} 

public class SomeInterfaceSupport implements SomeInterface { 
    public void aMethod() { 
     //implementation 
    } 
} 

public enum ResourceState implements SomeInterface { 
    RUNNING, STOPPING,STARTTING; 

    SomeInterfaceSupport someInterfaceSupport; 

    ResourceState() { 
     someInterfaceSupport = new SomeInterfaceSupport(); 
    } 

    @Override 
    public void aMethod() { 
     someInterfaceSupport.aMethod(); 
    } 
} 
+0

Non sarebbe 'public class SomeInterfaceSupport 'deve essere' public class SomeInterfaceSupport implementa SomeInterface'? –

+0

Sì, corretto. – dcernahoschi

Problemi correlati