1

我正在设计一个添加变量的网页，变量的类型可以是 form Double, String, ... 用户必须选择其中一种类型。后端将根据用户定义的类型创建变量。

我正在考虑拥有可以解决此问题的通用枚举。喜欢; 

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

    private String name;
    private Type type;
}

这样页面加载 REST 调用/variable/types会从枚举返回类型列表并填充下拉列表。

当用户根据传递的字符串提交表单时，aType是关联的。

似乎我正在做的事情是无效的，所以我正在寻找更好的方法来做到这一点，请指教

4

1 回答 1

0

在开始我的回答之前，我想说一个枚举是一个枚举，即命名某物的有限集合。

那东西是静态的最终对象。所以

enum MyEnum {A,B,C;}

引擎盖下是这样的：

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

因此，由于我认为您对枚举的所有可能类型不感兴趣（最后您有一个固定的组合），因此我建议您提供一个解决方案，该解决方案试图最大程度地减少工作量，并且一旦您选择了就可以非常简单地实现您想要支持的类型。在我的解决方案中，我选择了 Longs、Doubles、Points 和 Strings

我直接给你代码，如果你认为这个解决方案符合你的需求，我很乐意根据你的意见和要求进行改进。

// 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);
}

然后：

// 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);
    }

}

和一个测试类：

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);

    }

}

这个想法很简单，每次需要支持新类型时，添加一个枚举元素。抽象方法将迫使您实现存储、验证和解析（保存在 db 上是下一个？）您的值所需的一切。每次您需要一个新功能（是的，例如保存在 db 上）时，添加一个新的抽象方法，您将被迫为您决定支持的每种类型实现它。

希望这可以帮助。

于 2013-01-21T21:45:38.940 回答