Métodos Java Enum: devuelve la enumeración en dirección opuesta

Me gustaría declarar una dirección de enumeración, que tiene un método que devuelve la dirección opuesta (lo siguiente no es sintácticamente correcto, es decir, no se pueden crear instancias de enumeraciones, pero ilustra mi punto). ¿Es esto posible en Java?

Aquí está el código:

public enum Direction {

     NORTH(1),
     SOUTH(-1),
     EAST(-2),
     WEST(2);

     Direction(int code){
          this.code=code;
     }
     protected int code;
     public int getCode() {
           return this.code;
     }
     static Direction getOppositeDirection(Direction d){
           return new Direction(d.getCode() * -1);
     }
}

Para aquellos atraídos aquí por el título: sí, puede definir sus propios métodos en su enumeración. Si se pregunta cómo invocar dicho método no estático, hágalo de la misma manera que con cualquier otro método no estático: lo invoca en una instancia del tipo que define o hereda ese método. En el caso de enumeraciones, estos casos son simplemente ENUM_CONSTANTs.

Así que todo lo que necesitas es EnumType.ENUM_CONSTANT.methodName(arguments).

Ahora volvamos al problema de la pregunta. Una de las soluciones podría ser

public enum Direction {

    NORTH, SOUTH, EAST, WEST;

    private Direction opposite;

    static {
        NORTH.opposite = SOUTH;
        SOUTH.opposite = NORTH;
        EAST.opposite = WEST;
        WEST.opposite = EAST;
    }

    public Direction getOppositeDirection() {
        return opposite;
    }

}

Ahora Direction.NORTH.getOppositeDirection()volverá Direction.SOUTH.

Aquí hay una forma un poco más "hacky" de ilustrar el comentario de @jedwards, pero no se siente tan flexible como el primer enfoque, ya que agregar más campos o cambiar su orden romperá nuestro código.

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

    // cached values to avoid recreating such array each time method is called
    private static final Direction[] VALUES = values();

    public Direction getOppositeDirection() {
        return VALUES[(ordinal() + 2) % 4]; 
    }
}

Para una pequeña enumeración como esta, encuentro que la solución más legible es:

public enum Direction {

    NORTH {
        @Override
        public Direction getOppositeDirection() {
            return SOUTH;
        }
    }, 
    SOUTH {
        @Override
        public Direction getOppositeDirection() {
            return NORTH;
        }
    },
    EAST {
        @Override
        public Direction getOppositeDirection() {
            return WEST;
        }
    },
    WEST {
        @Override
        public Direction getOppositeDirection() {
            return EAST;
        }
    };


    public abstract Direction getOppositeDirection();

}

Esto funciona:

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

    public Direction oppose() {
        switch(this) {
            case NORTH: return SOUTH;
            case SOUTH: return NORTH;
            case EAST:  return WEST;
            case WEST:  return EAST;
        }
        throw new RuntimeException("Case not implemented");
    }
}

Cree un método abstracto y haga que cada uno de sus valores de enumeración lo anule. Como sabe lo contrario mientras lo crea, no es necesario generarlo o crearlo dinámicamente.

Sin embargo, no se lee bien; tal vez switchsería más manejable?

public enum Direction {
    NORTH(1) {
        @Override
        public Direction getOppositeDirection() {
            return Direction.SOUTH;
        }
    },
    SOUTH(-1) {
        @Override
        public Direction getOppositeDirection() {
            return Direction.NORTH;
        }
    },
    EAST(-2) {
        @Override
        public Direction getOppositeDirection() {
            return Direction.WEST;
        }
    },
    WEST(2) {
        @Override
        public Direction getOppositeDirection() {
            return Direction.EAST;
        }
    };

    Direction(int code){
        this.code=code;
    }
    protected int code;

    public int getCode() {
        return this.code;
    }

    public abstract Direction getOppositeDirection();
}

Sí, lo hacemos todo el tiempo. Devuelve una instancia estática en lugar de un nuevo objeto

 static Direction getOppositeDirection(Direction d){
       Direction result = null;
       if (d != null){
           int newCode = -d.getCode();
           for (Direction direction : Direction.values()){
               if (d.getCode() == newCode){
                   result = direction;
               }
           }
       }
       return result;
 }

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

    public Direction getOppositeDirection(){
        return Direction.values()[(this.ordinal() + 2) % 4];
    }
}

Las enumeraciones tienen un método de valores estáticos que devuelve una matriz que contiene todos los valores de la enumeración en el orden en que se declaran. fuente

dado que NORTE obtiene 1, ESTE obtiene 2, SUR obtiene 3, OESTE obtiene 4; puedes crear una ecuación simple para obtener la opuesta:

(valor + 2)% 4