uso - ¿Hay un operador de incremento++ para la enumeración de Java?

sobrecarga de operadores c++

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Cuál es la mejor manera de implementar `next` y` previous` en un tipo de enumeración? 2 respuestas

¿Es posible implementar el operador ++ para una enumeración?

Manejo el estado actual de una máquina de estados con una enumeración y sería bueno poder usar el operador ++ .

Answer 1

No puede "incrementar" una enumeración, pero puede obtener la siguiente enumeración:

// MyEnum e;
MyEnum next = MyEnum.values()[e.ordinal() + 1];

Pero mejor sería crear un método de instancia en su enumeración.

Note bien cómo se maneja el siguiente valor problemático para la última instancia de enumeración, para la cual no hay una instancia "siguiente":

public enum MyEnum {

    Alpha,
    Bravo,
    Charlie {
        @Override
        public MyEnum next() {
            return null; // see below for options for this line
        };
    };

    public MyEnum next() {
        // No bounds checking required here, because the last instance overrides
        return values()[ordinal() + 1];
    }
}

Para que pudieras hacer esto:

// MyEnum e;
e = e.next();

Las opciones razonables que tiene para la implementación del método overidden next() incluyen:

• return null; // there is no "next"
• return this; // capped at the last instance
• return values()[0]; // rollover to the first
• throw new RuntimeException(); // or a subclass like NoSuchElementException

La anulación del método evita el costo potencial de generar la matriz de values() para verificar su longitud. Por ejemplo, una implementación para next() donde la última instancia no la invalida podría ser:

public MyEnum next() {
    if (ordinal() == values().length - 1)
        throw new NoSuchElementException();
    return values()[ordinal() + 1];
}

Aquí, tanto el ordinal() como los values() se llaman (generalmente) dos veces , lo que costará más ejecutar que la versión anulada anteriormente.

Answer 2

No. Java no admite la sobrecarga de operadores personalizados para ningún tipo definido por el usuario, incluidas las enumeraciones.

Sin embargo, podría definir un método en la clase de enumeración que devolvió el siguiente enumerador.