Méthodes Java Enum

Question

Je voudrais déclarer une direction enum, qui a une méthode qui retourne 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 elles illustrent mon propos). 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);
     }
}
 

Answer 1

Que diriez-vous de quelque chose comme

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

}
 

---

Voici un peu plus "hacky" pour illustrer le commentaire de Jedwards, mais il n’est pas aussi flexible que la première approche, alors choisissez judicieusement :)

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

    public Direction getOppositeDirection() {
        return values()[(ordinal() + 2) % 4];
    }
}
 

Answer 2

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

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

}
 

Answer 3

Créez une méthode abstraite et faites-la remplacer par chacune de vos valeurs d'énumération. Comme vous savez le contraire lorsque 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 qu'un switch serait plus facile à gérer?

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

Answer 4

Oui on le fait tout le temps. Vous retournez 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;
 }