Enum within an enum

Question

This isn\'t a matter of me being stuck, but rather I\'m looking for a tidy way to write my code.

Essentially, I\'m writing an event driven application. The user trig

Answer 1

Perhaps use an inheritance hierarchy for the Events?

So you have:

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

It may make more sense to have:

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

If all the Move events have a distance, then pass that into the MoveEvent constructor (which will ripple down).

Answer 2

you can nest them in an arbitrary order like this:

package nested;

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

Answer 3

I believe that in Java, you can simply nest enums, as long as your non-enum constants come first.

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

This compiles for me and gives me the behavior you were looking for.