name - java enum valueof

Métodos Java Enum

Question

Me gustaría declarar una Dirección enum, que tiene un método que devuelve la dirección opuesta (lo siguiente no es sintácticamente correcto, es decir, las enumeraciones no se pueden crear instancias, pero ilustra mi punto). ¿Es esto posible en Java?

Aquí está el código:

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

Cree un método abstracto y haga que cada uno de sus valores de enumeración lo anule. Como sabes lo contrario mientras lo creas, no hay necesidad de generarlo o crearlo dinámicamente.

Aunque no lee bien; quizás un switch sería más manejable?

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 2

Esto funciona:

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

Answer 3

Para los atraídos aquí por título: sí, puedes definir tus propios métodos en enumeración. Si se pregunta cómo invocar dicho método no estático, lo hace de la misma manera que con cualquier otro método no estático; lo invoca en instancia del tipo que define o hereda ese método. En el caso de las enumeraciones, tales instancias son simplemente ENUM_CONSTANT s.

Entonces, todo lo que necesita es EnumType.ENUM_CONSTANT.methodName(arguments) .

Ahora regresemos al problema de la pregunta. Una de las soluciones podría ser

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

}

Ahora Direction.NORTH.getOppositeDirection() devolverá Direction.SOUTH .

Aquí hay una forma más "hacky" de ilustrar el comentario de @jedwards pero no se siente tan flexible como el primer acercamiento

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

    private static final Direction[] VALUES = values();//cached values 
                                                       //to avoid recreating array

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

Answer 4

Para una enumeración pequeña como esta, creo que la solución más legible es:

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 5

Sí lo hacemos todo el tiempo. Devuelve una instancia estática en lugar de un nuevo objeto

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

Answer 6

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

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

Los enumerados tienen un método de valores estáticos que devuelve una matriz que contiene todos los valores de la enumeración en el orden en que se declaran. source

dado que NORTH obtiene 1, EAST obtiene 2, SOUTH obtiene 3, WEST obtiene 4; puedes crear una ecuación simple para obtener la opuesta:

(valor + 2)% 4