Métodos Java Enum - retorna enum de direção oposta

Eu gostaria de declarar um enum Direction, que tem um método que retorna a direção oposta (o seguinte não é sintaticamente correto, ou seja, enums não podem ser instanciados, mas ilustra meu ponto). Isso é possível em Java?

Aqui está o 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 aqueles atraídos aqui pelo título: sim, você pode definir seus próprios métodos em seu enum. Se você está se perguntando como invocar esse método não estático, faça-o da mesma forma que com qualquer outro método não estático - invoque-o na instância do tipo que define ou herda esse método. No caso de enums, essas instâncias são simplesmente ENUM_CONSTANTs.

Então, tudo que você precisa é EnumType.ENUM_CONSTANT.methodName(arguments).

Agora vamos voltar ao problema da pergunta. Uma das soluções pode 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;
    }

}

Agora Direction.NORTH.getOppositeDirection()vai voltar Direction.SOUTH.

Aqui está uma forma um pouco mais "hacky" de ilustrar o comentário @jedwards, mas não parece tão flexível quanto a primeira abordagem, pois adicionar mais campos ou alterar sua ordem quebrará nosso 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 um pequeno enum como este, acho que a solução mais legível é:

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

}

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

Crie um método abstrato e faça com que cada um dos valores de enumeração o substitua. Como você sabe o oposto ao criá-lo, não há necessidade de gerá-lo ou criá-lo dinamicamente.

Embora não tenha uma boa leitura; talvez um switchfosse mais gerenciável?

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

Sim, fazemos isso o tempo todo. Você retorna uma instância estática em vez de um novo 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];
    }
}

Enums têm um método de valores estáticos que retorna uma matriz contendo todos os valores do enum na ordem em que são declarados. fonte

uma vez que NORTH obtém 1, EAST obtém 2, SOUTH obtém 3, WEST obtém 4; você pode criar uma equação simples para obter o oposto:

(valor + 2)% 4