Java: ¿Puedo usar dos nombres diferentes en una enumeración para contar como lo mismo?

Question

que tienen una clase de enumeración con los puntos cardinales (norte, este, sur, oeste):

public enum Direction { 
    NORTH, 
    EAST, 
    SOUTH, 
    WEST; 
} 

¿Hay una manera de ser capaz de utilizar varios nombres para la misma cosa? Por ejemplo algo como esto:

public enum Direction { 
    NORTH or N, 
    EAST or E, 
    SOUTH or S, 
    WEST or W; 
} 

En la práctica, lo que quiero es poder y firme a una variable N o al norte y al tener las dos operaciones sean exactamente los mismos.

Ejemplo:

Direction direction1=new Direction.NORTH; 
Direction direction2=new Direction.N; 
//direction1==direction2 

Answer 1

public enum Direction { 
    NORTH, 
    EAST, 
    SOUTH, 
    WEST, 
    ; 

    // Convenience names. 
    public static final Direction N = NORTH; 
    public static final Direction E = EAST; 
    public static final Direction S = SOUTH; 
    public static final Direction W = WEST; 
} 

es legal, pero "N" no funcionará con el método de auto-generado valueOf. Es decir. Direction.valueOf("N") lanzará un IllegalArgumentException en lugar de devolver Direction.NORTH.

Tampoco puede escribir case N:. Debe usar los nombres completos en switch es cuyo valor es Direction.

Aparte de eso, la forma abreviada debería funcionar igual de bien que la versión completa. Se puede utilizar en Direction.NEnumSet s, compararlo por la igualdad Direction.N == Direction.NORTH, obtener su name() (que es "NORTH"), import static yourpackage.Direction.N;, etc.

Answer 2

Se podría hacer algo como esto (este y oeste se omite).

public enum Direction { 
    NORTH { 
     @Override 
     Direction getDirection() { 
      return NORTH; 
     } 
    }, 
    N { 
     @Override 
     Direction getDirection() { 
      return NORTH; 
     } 
    }, 
    SOUTH { 
     @Override 
     Direction getDirection() { 
      return SOUTH; 
     } 
    }, 
    S { 
     @Override 
     Direction getDirection() { 
      return SOUTH; 
     } 
    } ; 

    abstract Direction getDirection(); 
} 

entonces se podría algo como esto

public void foo(Direction arg) { 
    Direction d = arg.getDirection(); 
} 

A continuación usted tendrá que lidiar con sólo el norte, sur, este y oeste.

Answer 3

Hum, tal vez tener un "cliente Enum" con las variables que contienen la actual "Enum significativa"?

public enum Direction { 
    NORTH(BaseDirection.NORTH), 
    N(BaseDirection.NORTH), 
    EAST(BaseDirection.EAST), 
    E(BaseDirection.EAST), 
    SOUTH(BaseDirection.SOUTH), 
    S(BaseDirection.SOUTH), 
    WEST(BaseDirection.WEST), 
    W(BaseDirection.WEST); 

    private BaseDirection baseDirection; 

    private Direction(BaseDirection baseDirection) { 
     this.baseDirection = baseDirection; 
    } 

    public BaseDirection getBaseDirection() { 
     return baseDirection; 
    }   
} 

public enum BaseDirection { 
    NORTH, 
    EAST, 
    SOUTH, 
    WEST; 
} 

Un poco exagerado, pero se puede exponer a la dirección de código de cliente y utilizar getBaseDirection para la lógica real.