Re: Extending Enum

From:

Daniel Pitts <googlegroupie@coloraura.com>

Newsgroups:

comp.lang.java.programmer

Date:

15 May 2007 16:45:07 -0700

Message-ID:

<1179272707.184636.306320@q23g2000hsg.googlegroups.com>

On May 15, 10:00 am, "lrol...@gmail.com" <lrol...@gmail.com> wrote:

Hi all

Due to a somewhat strange external requirement I need to ensure that
most of our enums can be treated as a single type that contains a
getDescription() method. Given the enum keyword is just syntactic
sugar for extending the Enum abstract class my initial idea was to do
something like this:
--
public interface EnumDescription<E extends Enum<E>> {
        public String getDescription();}

--

With the implementing enum ending up as
--
public enum Flag implements EnumDescription<Flag> {
        ALL("All"), UNFLAGGED("Unflagged"), RED("Flagged with red flag"),
GREEN(
                        "Flagged with green flag"), BLUE("Flagged with blue flag");
        private String description;
        Flag(String description) {
                this.description = description;
        }
        public String getDescription() {
                return description;
        }}

--

Which of cause looses all the enum type information - i.e. the
following will not work because "ordinal" does not exists in the
interface.

--
public static void main(String[] args) {
        // full enums
        Flag[] flags = Flag.values();

        // print description and ordinal
        String s = new String();
        for (EnumDescription<?> d : flags) {
                s += " '" + d.getDescription() + " (id: " + d.ordinal() + ")' ";
        }
        System.out.println(s);}

--

Given i also need the other enum methods (valueOf...) it does not
seams like a sensible solution to just add then to the interface
(valueOf is also static which creates its own set of problems). So
basically I need a way to keep the type information from Enum in my
new type - is this even possible ?.

Check all this out:

public class Test {
    public static interface HasDescription<Type extends Enum<Type> &
HasDescription<Type>> {
        String getDescription();
        int ordinal();
        Class<Type> getDeclaringClass();

    }

    public enum MyEnum implements HasDescription<MyEnum> {
        MINE {
            public String getDescription() {
                return "What's mine is mine.";
            }
        },
        YOURS {
            public String getDescription() {
                return "What's your is mine.";
            }
        }
    }

    public static void main(String[] args) {
        HasDescription<? extends HasDescription> thing = MyEnum.YOURS;
        System.out.println(thing.getDescription() + thing.ordinal());
        HasDescription[] enumConstants =
thing.getDeclaringClass().getEnumConstants();
        for (HasDescription e: enumConstants) {
            System.out.println(e + ": " + e.getDescription() +
e.ordinal());
        }
    }
}