Méthodes Java Enum - retourne une énumération dans la direction opposée

Je voudrais déclarer une direction enum, qui a une méthode qui renvoie la direction opposée (ce qui suit n'est pas syntaxiquement correct, c'est-à-dire que les énumérations ne peuvent pas être instanciées, mais cela illustre mon point). Est-ce possible en Java?

Voici le code:

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

Pour ceux qui sont attirés ici par leur titre: oui, vous pouvez définir vos propres méthodes dans votre énumération. Si vous vous demandez comment invoquer une telle méthode non statique, vous le faites de la même manière qu'avec toute autre méthode non statique - vous l'appelez sur une instance de type qui définit ou hérite de cette méthode. Dans le cas d'énumérations, ces instances sont simplement l' ENUM_CONSTANTart.

Donc, tout ce dont vous avez besoin est EnumType.ENUM_CONSTANT.methodName(arguments).

Revenons maintenant au problème à partir de la question. L'une des solutions pourrait être

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

}

Je Direction.NORTH.getOppositeDirection()reviendrai maintenant Direction.SOUTH.

Voici une manière un peu plus «hacky» d'illustrer le commentaire @jedwards mais cela ne semble pas aussi flexible que la première approche car l'ajout de plus de champs ou la modification de leur ordre cassera notre code.

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

Pour une petite énumération comme celle-ci, je trouve que la solution la plus lisible est:

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

}

Cela marche:

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

Créez une méthode abstraite et faites en sorte que chacune de vos valeurs d'énumération la remplace. Puisque vous savez le contraire pendant que vous le créez, il n'est pas nécessaire de le générer ou de le créer dynamiquement.

Il ne lit pas bien cependant; peut-être un switchserait plus gérable?

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

Oui, nous le faisons tout le temps. Vous renvoyez une instance statique plutôt qu'un nouvel objet

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

Les énumérations ont une méthode de valeurs statiques qui renvoie un tableau contenant toutes les valeurs de l'énumération dans l'ordre dans lequel elles sont déclarées. la source

puisque NORTH obtient 1, EAST obtient 2, SUD obtient 3, WEST obtient 4; vous pouvez créer une équation simple pour obtenir l'inverse:

(valeur + 2)% 4