Java Enum che fa riferimento a un'altra enumerazione

Question

Mi piacerebbe essere in grado di definire una classe Enum che includa un altro Enum oltre ai propri valori. Ad esempio,:

public enum A { 
    A1, A2, A3; 
} 

public enum B{ 
    B1, B2, ...(somehow define references to all values in enum A) 
} 

tali che tutti i valori contenuti nella enum B devono essere o initself (come B1, B2) o qualsiasi valore di enumerazione A. definiti

Grazie,

Answer 1

Tale che B è l'unione di A e B? Ciò non è possibile senza B che estende A, che è not supported in java. Il modo di procedere è quello di creare un enum che contiene i valori combinati di A e B, per esempio,

enum C { 
    A1, A2, A3, B1, B2; 
} 

Answer 2

qualcosa di simile?

enum A { 
    A1, A2; 
} 

enum B { 
    B1(null), 
    B2(null), 
    A1(A.A1), 
    A2(A.A2); 

    private final A aRef; 
    private final B(A aRef) { 
     this.aRef = aRef; 
    } 
} 

Answer 3

Il massimo che si può ottenere è che A e B implementino un'interfaccia condivisa.

enum A implements MyEnum{A1,A2} 
enum B implements MyEnum{B1,B2} 

MyEnum e = B.B1; 

Questa soluzione non funzionerà con l'istruzione switch, né con le collezioni enum ottimizzati.

Il tuo caso d'uso non è supportato dall'implementazione di java enum, era troppo complesso da implementare (rispetto alla sua utilità) o non è venuto fuori (nessuna delle poche lingue che so supporta direttamente questo) .

Answer 4

In genere, dal momento che stiamo lavorando in java e di solito si presta la progettazione OO, è possibile ottenere questa funzionalità tramite l'estensione. Tuttavia, enum estende java.lang.Enum implicitamente e pertanto non può estendere un'altra classe.

Ciò significa che l'estensibilità per le enumerazioni può essere ricavata da una fonte diversa.

Joshua Bloch aggiunge questo in Java efficace: seconda edizione nell'elemento 34, quando presenta un modello di interfaccia condiviso per enumerazioni. Ecco il suo esempio del pattern:

public interface Operation { 
     double apply(double x, double y); 
    } 

    public enum BasicOperation implements Operation { 
     PLUS("+") { 
      public double apply(double x, double y) { return x + y; } 
     }, 
     MINUS("-") { 
      public double apply(double x, double y) { return x - y; } 
     }, 
     TIMES("*") { 
      public double apply(double x, double y) { return x * y; } 
     }, 
     DIVIDE("/") { 
      public double apply(double x, double y) { return x/y; } 
    } 

Questo è quanto di più vicino si può arrivare a stato condiviso quando si tratta di enumerazioni. Come ha detto in precedenza Johan Sjöberg, potrebbe essere semplicemente più semplice combinare semplicemente le enumerazioni in un'altra enumerazione.

Buona fortuna!