Metodi Java Enum: restituisce enum in direzione opposta

Vorrei dichiarare una enum Direction, che ha un metodo che restituisce la direzione opposta (il seguente non è sintatticamente corretto, cioè, le enumerazioni non possono essere istanziate, ma illustra il mio punto). È possibile in Java?

Ecco il codice:

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

Per coloro che sono attirati qui dal titolo: sì, puoi definire i tuoi metodi nella tua enumerazione. Se ti stai chiedendo come invocare tale metodo non statico, lo fai allo stesso modo di qualsiasi altro metodo non statico: lo invochi su un'istanza di tipo che definisce o eredita quel metodo. In caso di enum tali istanze sono semplicemente ENUM_CONSTANTs.

Quindi tutto ciò di cui hai bisogno è EnumType.ENUM_CONSTANT.methodName(arguments).

Ora torniamo al problema dalla domanda. Una delle soluzioni potrebbe essere

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

}

Ora Direction.NORTH.getOppositeDirection()tornerà Direction.SOUTH.

Ecco un modo un po 'più "hacky" per illustrare il commento @jedwards, ma non sembra flessibile come il primo approccio poiché l'aggiunta di più campi o la modifica del loro ordine interromperà il nostro codice.

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

Per una piccola enumerazione come questa, trovo che la soluzione più leggibile sia:

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

}

Funziona:

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

Crea un metodo astratto e fai in modo che ciascuno dei tuoi valori di enumerazione lo sovrascriva. Poiché sai il contrario mentre lo crei, non è necessario generarlo o crearlo dinamicamente.

Non si legge bene però; forse switchsarebbe più gestibile?

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 facciamo sempre. Restituisci un'istanza statica anziché un nuovo oggetto

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

Gli enum hanno un metodo di valori statici che restituisce un array contenente tutti i valori dell'enumerazione nell'ordine in cui vengono dichiarati. fonte

poiché NORTH ottiene 1, EAST ottiene 2, SUD ottiene 3, WEST ottiene 4; puoi creare una semplice equazione per ottenere quella opposta:

(valore + 2)% 4