Java enum - Impossibile fare riferimento a un campo prima che sia definito

Question

Ho un enumerato come quello qui sotto, ma eclissi dice che ci sono errori nella prima definizione di ogni coppia opposta.

public enum Baz{ 
    yin(yang), //Cannot reference a field before it is defined 
    yang(yin), 
    good(evil), //Cannot reference a field before it is defined 
    evil(good); 

    public final Baz opposite; 

    Baz(Baz opposite){ 
    this.opposite = opposite; 
    } 
} 

Quello che voglio realizzare è di essere in grado di utilizzare Baz.something.opposite per ottenere l'oggetto opposta di Baz.something. C'è una soluzione possibile per questo? Forse un segnaposto vuoto per yang e bad prima di yin e good sono definiti in questo esempio?

Answer 1

Si potrebbe provare qualcosa di simile:

public enum Baz{ 
    yin("yang"),  
    yang("yin"), 
    good("evil"), 
    evil("good"); 

    private String opposite; 

    Baz(String opposite){ 
    this.opposite = opposite; 
    } 

    public Baz getOpposite(){ 
    return Baz.valueOf(opposite); 
    } 
} 

e quindi fare riferimento come

Baz.something.getOpposite() 

Questo dovrebbe compiere ciò che si sta cercando di fare, cercando il valore enum da esso di rappresentazione di stringa. Non penso che tu possa farlo funzionare con il riferimento ricorsivo a Baz.

Answer 2

Con l'istruzione switch:

public enum Baz{ 
    yin, 
    yang, 
    good, 
    evil; 

    public Baz getOpposite() { 
    switch (this) { 
     case yin: return yang; 
     case yang: return yin; 
     case good: return evil; 
     case evil: return good; 
    } 
    throw new AssertionError(); 
} 

o differito di inizializzazione:

public enum Baz{ 
    yin, 
    yang, 
    good, 
    evil; 

    public Baz opposite; 

    static { 
    yin.opposite = yang; 
    yang.opposite = yin; 
    good.opposite = evil; 
    evil.opposite = good; 
    } 
} 

Si potrebbe voler rendere il campo mutabile privato e fornire un getter.

Answer 3

E ancora un'altra implementazione possibile (simile ad alcune delle altre soluzioni, ma con una HashMap).

import java.util.Map; 
import java.util.HashMap; 

public enum Baz { 
yin, 
yang, 
good, 
evil; 

private static Map<Baz, Baz> opposites = new HashMap<Baz, Baz>(); 
static { 
    opposites.put(yin, yang); 
    opposites.put(yang, yin); 
    opposites.put(good, evil); 
    opposites.put(evil, good); 
} 


public Baz getOpposite() { 
    return opposites.get(this); 
} 

} 

Answer 4

Che ne dici di un EnumMap?

public enum Baz { 
    yin, 
    yang, 
    good, 
    evil; 
    private static final Map<Baz, Baz> opposites = new EnumMap<Baz, Baz>(Baz.class); 

    static { 
    opposites.put(yin, yang); 
    opposites.put(yang, yin); 
    opposites.put(good, evil); 
    opposites.put(evil, good); 
    } 

    public Baz getOpposite() { 
    return opposites.get(this); 
    } 
} 

Answer 5

Un'altra alternativa :) utilizzando una mappa. È abbastanza dettagliato, ma in questo modo è possibile definire ogni coppia solo una volta, l'altra direzione viene dedotta.

enum Baz { 

    YIN, YANG, GOOD, EVIL; 

    private static final Map<Baz, Baz> opposites = new EnumMap<>(Baz.class); 

    static { 
     opposites.put(YIN, YANG); 
     opposites.put(GOOD, EVIL); 

     for (Entry<Baz, Baz> entry : opposites.entrySet()) { 
      opposites.put(entry.getValue(), entry.getKey()); 
     } 
    } 

    public Baz opposite() { 
     return opposites.get(this); 
    } 
} 

Personalmente, mi piace Meriton 's secondo esempio il meglio.

Answer 6

E poi c'è la soluzione totalmente OTT.

public enum Baz { 
    yin, 
    yang, 
    good, 
    evil, 
    right, 
    wrong, 
    black, 
    white; 

    private static class AutoReversingMap<K extends Enum<K>> extends EnumMap<K, K> { 
    public AutoReversingMap(Class<K> keys) { 
     super(keys); 
    } 

    // Make put do both the forward and the reverse. 
    public K put(K key, K value) { 
     super.put(key, value); 
     super.put(value, key); 
     // Better to return null here than a misleading real return of one of the supers. 
     return null; 
    } 
    } 
    private static final Map<Baz, Baz> opposites = new AutoReversingMap<Baz>(Baz.class); 

    static { 
    // Assume even and odd ones are opposites. 
    for (int i = 0; i < Baz.values().length; i += 2) { 
     opposites.put(Baz.values()[i], Baz.values()[i + 1]); 
    } 
    } 

    public Baz getOpposite() { 
    return opposites.get(this); 
    } 
} 

Answer 7

Anni dopo, la soluzione più breve e più hacky

public enum Baz { 
    YIN, // Use uppercase for enum names! 
    YANG, 
    GOOD, 
    EVIL; 

    public Baz opposite() { 
     return values()[ordinal()^1]; 
    } 
} 

Essa si basa sul presupposto che ogni membro ha un opposto e che stanno disposti a coppie. Sostituisce il campo con un metodo nella speranza, che la JVM ottimizzerà l'intero overhead. Questo è ragionevole sul desktop, meno ragionevole su Android.

Per eliminare il sovraccarico, potrei utilizzare l'inizializzatore statico come molte altre soluzioni qui.

Answer 8

È anche possibile utilizzare i metodi astratti per ritardare, con vantaggi della sicurezza del tipo rispetto alla risposta accettata.

public enum Baz { 

    yin(new OppositeHolder() { 
     @Override 
     protected Baz getOpposite() { 
      return yang; 
     } 
    }), 
    yang(new OppositeHolder() { 
     @Override 
     protected Baz getOpposite() { 
      return yin; 
     } 
    }), 
    good(new OppositeHolder() { 
     @Override 
     protected Baz getOpposite() { 
      return evil; 
     } 
    }), 
    evil(new OppositeHolder() { 
     @Override 
     protected Baz getOpposite() { 
      return good; 
     } 
    }); 

    private final OppositeHolder oppositeHolder; 

    private Baz(OppositeHolder oppositeHolder) { 
     this.oppositeHolder = oppositeHolder; 
    } 

    protected Baz getOpposite() { 
     return oppositeHolder.getOpposite(); 
    } 

    private abstract static class OppositeHolder { 
     protected abstract Baz getOpposite(); 
    } 

} 

E codice di prova, perché ne avevo bisogno ....

import org.junit.Test; 
import static org.junit.Assert.fail; 

public class BazTest { 

    @Test 
    public void doTest() { 
     for (Baz baz : Baz.values()) { 
      System.out.println("Baz " + baz + " has opposite: " + baz.getOpposite()); 
      if (baz.getOpposite() == null) { 
       fail("Opposite is null"); 
      } 
     } 
    } 
}