Java：如何创建通用的ENUM类型

Question

I am designing a web page that adds a variable and type of variable could be of form Double , String , ... The user will have to choose one of these types. The backend will create variables based on the type defined by user.

I was thinking to have generic enum which can solve this. Like;

public enum VariableType<Type> {
    Double("Double", Double);
    String("String", String);

    private String name;
    private Type type;
}  

such that a on page load a REST call /variable/types returns list of types from enum and populate the dropdown list.

When user submits form based on the string passed a Type is associated.

Seems like what I am doing is invalid, so I am looking for better ways to do this, please advice

Answer 1

Before starting my answer, I would like to say that an enum is an enumeration, that is a finite collections of named something.

That something are static final objects. So

enum MyEnum {A,B,C;}

under the hood is something like:

static final Object A = new MyEnum();
static final Object B = new MyEnum();
static final Object C = new MyEnum();

So, since I think you are not interested in having all possible types for your enum (at the end you have a fixed combo), I propose you a solution that tries to minimize effort and could be quite simple to implement once you have chosen the types you want to support. In my solution, I chose Longs, Doubles, Points and Strings

I give you directly the code, if you think that this solution goes toward your needs, I will be happy to improve is as your comments and request.

// MyType.java
package stackoverflow.answers;

import java.awt.Point;

public enum MyType {
    LONG {
        @Override
        public Object validateValue(Object o) {
            return (o instanceof Long) ? o : null;
        }

        @Override
        public Object parse(String s) {
            try {
                return Long.valueOf(s);
            } catch (Exception e) {
                return null;
            }

        }
    },
    DOUBLE {
        @Override
        public Object validateValue(Object o) {
            return (o instanceof Double) ? o : null;
        }

        @Override
        public Object parse(String s) {
            try {
                return Double.valueOf(s);
            } catch (Exception e) {
                return null;
            }

        }
    },
    STRING {
        @Override
        public Object validateValue(Object o) {
            return (o instanceof String) ? o : null;
        }

        @Override
        public Object parse(String s) {
            // stupid method, but needed.
            return s;

        }
    },
    AWTPOINT {
        @Override
        public Object validateValue(Object o) {
            return (o instanceof Point) ? o : null;
        }

        @Override
        public Object parse(String s) {
            if (s == null)
                return null;
            String ss[] = s.split(",");
            if (ss.length != 2)
                return null;
            try {
                return new Point(Integer.valueOf(ss[0]), Integer.valueOf(ss[1]));
            } catch (Exception e) {
                return null;
            }

        }
    };

    public String toString(Object o) {
        return o.toString();
    }

    public abstract Object validateValue(Object o);

    public abstract Object parse(String s);
}

then:

// GenericObject.java
package stackoverflow.answers;

public class GenericObject {

    private MyType _type;
    private Object _obj;

    public GenericObject(MyType type) {
        _type = type;
    }

    public void setValue(Object obj) {
        _obj = _type.validateValue(obj);
    }

    public void valueOf(String s) {
        _obj = _type.parse(s);
    }

    public String toString() {
        return _type.toString(_obj);
    }

}

and a test class:

package stackoverflow.answers;

public class EnumTest {

    public static void main(String[] args) {
        GenericObject o1 = new GenericObject(MyType.LONG);
        o1.setValue(new Long(42));

        GenericObject o2 = new GenericObject(MyType.DOUBLE);
        o2.valueOf("3.14");

        GenericObject o3 = new GenericObject(MyType.AWTPOINT);
        o3.valueOf("4,-30");

        System.out.println(o1);
        System.out.println(o2);
        System.out.println(o3);

    }

}

The idea is quite simple, every time you need to support a new type, add an enum element. Abstract methods will force you to implement all you need to store, validate and parse (save on db is the next?) your values. Every time you need a new function (yes, like save on db), add a new abstract method and you will be forced to implement it for every type you decided to support.

Hope this helps.