Java enumeración- No se puede hacer referencia a un campo antes de que se defina

Question

Tengo una enumeración como la siguiente, pero eclipse dice que hay errores en la primera definición de cada par opuesto.

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; 
    } 
} 

Lo que quiero lograr es ser capaz de utilizar Baz.something.opposite para obtener el objeto opuesta de Baz.something. ¿Hay una posible solución para esto? ¿Tal vez un marcador de posición vacío para yang y bad antes de yin y good se definen en este ejemplo?

Answer 1

Usted podría intentar algo como:

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); 
    } 
} 

y luego hacer referencia a ella como

Baz.something.getOpposite() 

Eso debería lograr lo que usted está buscando para hacer buscando el valor de enumeración por ella de representación de cadena. No creo que puedas hacer que funcione con la referencia recursiva a Baz.

Answer 2

Con la sentencia 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 diferida de inicialización:

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

    public Baz opposite; 

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

Es posible que desee hacer que el campo mutable privada y proporcionar un captador.

Answer 3

Y aún otra posible implementación (similar a algunas de las otras soluciones, pero con un 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

¿Qué tal 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

Una alternativa más :) usando un mapa. Es bastante detallado, pero de esta manera puede definir cada par solo una vez, se infiere la otra dirección.

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, me gusta Meriton 's segundo ejemplo de lo mejor.

Answer 6

Y luego está la solución 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

Años después, la solución más corta y más hacky

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

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

Se basa en la suposición de que cada miembro tiene un opuesto y que están dispuestos por pares. Reemplaza el campo por un método con la esperanza de que la JVM optimice toda la sobrecarga. Esto es razonable en el escritorio, menos razonable en Android.

Para eliminar la sobrecarga, podría usar el inicializador estático como muchas otras soluciones aquí.

Answer 8

También puede usar métodos abstractos para retrasar, que tiene ventajas de seguridad del tipo sobre la respuesta aceptada.

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(); 
    } 

} 

Y código de prueba, porque lo necesitaba ....

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"); 
      } 
     } 
    } 
}