Java Enum Methods - zwraca wyliczenie w przeciwnym kierunku

Chciałbym zadeklarować kierunek wyliczenia, który ma metodę zwracającą przeciwny kierunek (poniższy kod nie jest poprawny składniowo, tj. Nie można utworzyć instancji wyliczeń, ale ilustruje to mój punkt widzenia). Czy to możliwe w Javie?

Oto kod:

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

Dla tych, zwabionych tutaj tytułem: tak, możesz zdefiniować własne metody w swoim enum. Jeśli zastanawiasz się, jak wywołać taką niestatyczną metodę, robisz to tak samo, jak każdą inną niestatyczną metodę - wywołujesz ją na instancji typu, która definiuje lub dziedziczy tę metodę. W przypadku wyliczeń takie przypadki są po prostu ENUM_CONSTANTs.

Więc wszystko, czego potrzebujesz, to EnumType.ENUM_CONSTANT.methodName(arguments).

Wróćmy teraz do problemu z pytania. Jednym z rozwiązań mogłoby być

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

}

Teraz Direction.NORTH.getOppositeDirection()wróci Direction.SOUTH.

Oto trochę bardziej "hacky" sposób zilustrowania komentarza @jedwards, ale nie wydaje się on tak elastyczny jak pierwsze podejście, ponieważ dodanie kolejnych pól lub zmiana ich kolejności zepsuje nasz kod.

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

W przypadku małego wyliczenia, takiego jak ten, najbardziej czytelnym rozwiązaniem jest:

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

}

To działa:

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

Utwórz metodę abstrakcyjną i zastąp ją każdą z wartości wyliczenia. Ponieważ podczas tworzenia wiesz, że jest odwrotnie, nie ma potrzeby dynamicznego generowania ani tworzenia.

Nie czyta się jednak ładnie; może switchbyłoby łatwiejsze w zarządzaniu?

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

Tak, robimy to cały czas. Zwracasz instancję statyczną zamiast nowego obiektu

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

Wyliczenia mają statyczną metodę wartości, która zwraca tablicę zawierającą wszystkie wartości wyliczenia w kolejności, w jakiej są zadeklarowane. źródło

ponieważ NORTH dostaje 1, EAST dostaje 2, SOUTH dostaje 3, WEST dostaje 4; możesz utworzyć proste równanie, aby otrzymać odwrotne:

(wartość + 2)% 4