Самый простой способ получить отзывчивую ориентацию enum? Java

Question

Я быстро показать то, что я хочу достичь в «ясном» способом:

public enum Orientation { 
    NORTH, WEST, SOUTH, EAST } 

public enum Turn { 
    LEFT, RIGHT } 

Так что я хочу, чтобы эти два перечислений сделать это безопасно и эффективно искать измененную ориентацию по ходу:

Orientation orient = Orientation.NORTH; 
// orient points to NORTH now 
orient = orient.turn(Turn.LEFT); 
// orient points to WEST now 

Первый способом, которым я пытался добиться этого был путем создания карты:

EnumMap<Orientation, EnumMap<Turn, Orientation>> 

и карты всех направлений статический, но -й на огромный кусок map.get.put.get .... и, вероятно, немного слишком передозировка, Altough в результате этого желаемого эффекта:

directionMap.get(NORTH).get(LEFT) 
// the value would then be WEST 

Следующий способ я пошел был через класс Compass, что связывает все ориентации в круг .. Работает как LinkedCircuitList ... < -> NORTH < -> EAST < -> SOUTH < -> WEST < -> NORTH < -> ... Итак, Compass может иметь статическую функцию, которая вызывает любой член этого связанного списка и шаг влево или вправо, что приведет к правильному изменению направления. Но код действительно не работал так, как я этого хотел.

Итак, мой вопрос, в конце концов, имеет ли кто-нибудь опыт в этом виде кода или имеет представление о том, как добиться желаемого результата в хорошем перечислении?

Answer 1

Я не вижу ничего плохого в решении карты. Если вы хотите что-то более consise:

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

    private static Orientation[] vals = values(); 

    Orientation turnTo(Turn t) { 
     return vals[(4 + this.ordinal() + (t == Turn.RIGHT ? 1 : -1)) % 4]; 
    } 
} 

Это, однако, является менее чистым и ремонтопригодны (это нарушило бы, если кто-то изменяет порядок перечислений).

Немного чище (но менее consise):

public enum Orientation { 
    NORTH(0), EAST(1), SOUTH(2), WEST(3); 

    private final int p; 

    Orientation(int p) { 
     this.p = p; 
    } 

    private static Orientation[] vals = new Orientation[4]; 
    static { 
     for(Orientation o : Orientation.values()) 
      vals[o.p] = o; 
    } 

    Orientation turnTo(Turn t) { 
     return vals[(4 + this.p + (t == Turn.RIGHT ? 1 : -1)) % 4]; 
    } 
} 

Answer 2

Я думаю, что ваша идея циклического списка очень хорошо:

public enum Turn { 
    LEFT(-1), RIGHT(1); 

    private final int offset; 

    private Turn(int offset) { 
     this.offset = offset; 
    } 

    public int offset() { 
     return this.offset; 
    } 
} 

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

    private static final List<Orientation> orientations = 
     Arrays.asList(NORTH, EAST, SOUTH, WEST); // to not depend on ordinal 

    public Orientation turn(Turn to) { 
     int size = orientations.size(); 
     int myIndex = orientations.indexOf(this); 
     int remainder = (myIndex + to.offset()) % size; 
     int index = remainder < 0 ? size + remainder : remainder; 
     return orientations.get(index); 
    } 
} 

Это кажется довольно растяжимое, т.е. HARD_LEFT бы -2 смещение и круговой список ориентаций следует заказывать слева направо.

Answer 3

Не использовать порядковые, и легко понять:

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

    static { 
     NORTH.left = WEST; 
     NORTH.right = EAST; 
     WEST.left = SOUTH; 
     WEST.right = NORTH; 
     EAST.left = NORTH; 
     EAST.right = SOUTH; 
     SOUTH.left = EAST; 
     SOUTH.right = WEST; 
    } 

    private Orientation left; 
    private Orientation right; 

    public Orientation turnTo(Turn t) { return t == Turn.LEFT ? left : right; } 
} 

Answer 4

Другой способ обмануть Java в принятии этого является использование методов вместо полей:

enum Orientation { 

    NORTH { 
     Orientation left(){return WEST;} 
     Orientation right(){return EAST;} 
    }, 
    EAST { 
     Orientation left(){return NORTH;} 
     Orientation right(){return SOUTH;} 
    }, 
    SOUTH { 
     Orientation left(){return EAST;} 
     Orientation right(){return WEST;} 
    }, 
    WEST { 
     Orientation left(){return SOUTH;} 
     Orientation right(){return NORTH;} 
    }; 

    abstract Orientation left(); 
    abstract Orientation right(); 

    public Orientation turn(Turn where){ 
     return where == Turn.LEFT ? this.left() : this.right(); 
    } 
} 

Вы можете спасти себя turn() и просто напишите что-нибудь вроде Orientation.North.left(), если хотите. Дает вам очень сжатый синтаксис.