java - significan - puntuación en listas rae

Enumeración dentro de una enumeración

Question

Esto no es una cuestión de que me quede atascado, sino que busco una forma ordenada de escribir mi código.

Esencialmente, estoy escribiendo una aplicación impulsada por eventos. El usuario activa un evento, el evento se envía a los objetos apropiados y los objetos manejan los eventos. Ahora estoy trabajando en escribir los métodos de control par, y esperaba usar sentencias de switch para determinar cómo manejar el evento. En este momento, mientras estoy trabajando en la estructura general, la clase de evento es realmente simple:

public class Event {

    public static enum Action {
        MOVE, FOO, BAR
    }

    private Action action;
    private int duration;

    public Event(Action action, int duration) {
        this.action = action;
        this.duration = duration;
    }

    public Action getAction() {
        return action;
    }

    public int getDuration() {
        return duration;
    }

Luego, en otra clase, tendré algo como:

public void handleEvent(Event evt) {    
    switch(Event.getAction()) {
        case MOVE: doSomething(); break;
        case FOO:  doSomething(); break;
        case BAR:  doSomething(); break;
        default: break; 
    }
}

Lo que me gustaría hacer es algo como esto (aunque, por supuesto, pegaría las declaraciones de cambio en sus propias funciones para evitar que se convierta en una bola de pelo desagradable de interruptores y cajas):

public void handleEvent(Event evt) {    
    switch(Event.getAction()) {
        case MOVE: switch(Event.getAction()) {
                       case UP:    break;
                       case DOWN:  break;
                       case LEFT:  break;
                       case RIGHT: break;
                   }
        case FOO:  break;
        case BAR:  break;
        default:   break; 
    }
}

Por lo tanto, me gustaría crear enumeraciones anidadas ... así:

public static enum Action {
    public enum MOVE {UP, DOWN, LEFT, RIGHT}, FOO, BAR
}

No es que no pueda evitar el escenario, simplemente sería ... conveniente. Entonces, mientras que lo anterior no funciona, ¿existe algún método similar para lograrlo? Sería bueno si pudiera enviar un evento con la acción "MOVE.UP", y el método lo identificaría primero como una acción de tipo MOVE, y luego identificaría que está específicamente en la dirección UP. Eso es solo un ejemplo simple, sería bueno si también pudiera hacer cadenas más largas, algo así como "DELETE.PAGE1.PARAGRAPH2.SENTENCE2.WORD11.LETTER3". De la manera que lo veo, solo tendré que usar cadenas y muchas declaraciones if / else. Esperando que haya una mejor manera! (Ah, y el rendimiento importa en mi caso, si eso ayuda)

Answer 1

¿Quizás usar una jerarquía de herencia para los eventos?

Así que tienes:

- abstract Event
-- MoveEvent(Direction)
-- FooEvent()
-- BarEvent()

Puede tener más sentido tener:

- abstract Event
-- abstract MoveEvent
--- MoveUpEvent
--- MoveDownEvent
--- MoveRightEvent
--- MoveLeftEvent
-- FooEvent
-- BarEvent

Si todos los eventos Move tienen una distancia, entonces páselos al constructor MoveEvent (que se ondulará hacia abajo).

Answer 2

Creo que en Java, simplemente puede anidar enumeraciones, siempre que sus constantes no enumeradas sean lo primero.

enum Action
{
    FOO,
    BAR;
    enum MOVE
    {
         UP,
         DOWN,
         LEFT,
         RIGHT 
    }
}

Esto me compila y me da el comportamiento que estabas buscando.

Answer 3

Puedes anidarlos en un orden arbitrario como este:

paquete anidado;

import java.util.*;
import nested.Citrus.Orange;
interface HasChildren {
    Set<Enum<?>> children();
}
enum Citrus implements HasChildren {
    lemon, lime, orange;
    Set<Enum<?>> children;
    enum Orange implements HasChildren {
        navel, valencia, blood;
        Set<Enum<?>> children;
        enum Navel implements HasChildren {
            washinton, lateLane, caraCaraPink;
            public Set<Enum<?>> children() {
                return null;
            }
        }
        static {
            navel.children = new LinkedHashSet<Enum<?>>();
            navel.children.addAll(EnumSet.allOf(Navel.class));
        }
        enum Blood implements HasChildren {
            moro, taroco;
            public Set<Enum<?>> children() {
                return null;
            }
        }
        static {
            blood.children = new LinkedHashSet<Enum<?>>();
            blood.children.addAll(EnumSet.allOf(Blood.class));
        }
        public Set<Enum<?>> children() {
            return children != null ? Collections.unmodifiableSet(children) : null;
        }
    }
    static {
        orange.children = new LinkedHashSet<Enum<?>>();
        orange.children.addAll(EnumSet.allOf(Orange.class));
    }
    public Set<Enum<?>> children() {
        return children != null ? Collections.unmodifiableSet(children) : null;
    }
}
public class EnumTreeNested {
    static void visit(Class<?> clazz) {
        Object[] enumConstants = clazz.getEnumConstants();
        if (enumConstants[0] instanceof HasChildren) for (Object o : enumConstants)
            visit((HasChildren) o, clazz.getName());
    }
    static void visit(HasChildren hasChildren, String prefix) {
        if (hasChildren instanceof Enum) {
            System.out.println(prefix + '' '' + hasChildren);
            if (hasChildren.children() != null) for (Object o : hasChildren.children())
                visit((HasChildren) o, prefix + '' '' + hasChildren);
        } else
            System.out.println("other " + hasChildren.getClass());
    }
    static <E extends Enum<E> & HasChildren> Set<E> foo() {
        return null;
    }
    public static void main(String[] args) {
        System.out.println(Citrus.Orange.Navel.washinton);
        visit(Citrus.lemon, "");
        System.out.println("----------------------");
        visit(Citrus.orange, "");
        System.out.println("----------------------");
        visit(Citrus.class);
        System.out.println("----------------------");
    }
}