Question

我正在构建具有如下数据结构的枚举值：

enum MetaType {
 HUMAN(
  new MetaTypeAttribute(AttributeType.BODY, 1, 6),
  new MetaTypeAttribute(AttributeType.AGILITY, 1, 6),
  new MetaTypeAttribute(AttributeType.REACTION, 1, 6)
 ),
 ORK(
  new MetaTypeAttribute(AttributeType.BODY, 4, 9),
  new MetaTypeAttribute(AttributeType.AGILITY, 1, 6),
  new MetaTypeAttribute(AttributeType.REACTION, 1, 6)
 );

 MetaType(MetaTypeAttribute body, MetaTypeAttribute agility, MetaTypeAttribute reaction) {
 }
}

因此有一个MetaTypes的枚举;每个MetaType指定一组固定的MetaTypeAttributes，它由该属性的最小值和最大值组成。

我讨厌这种语法。这太长了，它太丑了，它并没有阻止我传入错误的AttributeType（AttributeType应该与MetaType的构造函数的参数顺序匹配; AttributeType.BODY＆gt; body等）。我想要的是一个更好的模式，以确保用这个精确的方案构造一个对象。

此代码缩写。实际上有9种AttributeTypes。

有任何改进建议吗？

Answer 1

    enum MetaType {
 HUMAN(new MyRange(1,1), new MyRange(1, 10), new MyRange(1,10)
 ),
 ORK(new MyRange(1,1), new MyRange(1, 10), new MyRange(1,10)
 );

 MetaType(MyRange body, MyRange agility, MyRange reaction) {
      this.bodyAttrib = new MetaTaypAttibute(AttributeType.BODY, body);
      this.agilityAttrib = new MetaTaypAttibute(AttributeType.AGILITY, agility);
      this.reactionAttrib = new MetaTaypAttibute(AttributeType.REACTION, reactiony);}
}

Answer 2

如果您考虑不同的属性类型，也许您应该真正将这些属性类型创建为类/子类而不是枚举。您将拥有OOP的所有优点来处理每种类型的行为（继承的方法，方法重写，......），它们将是类型安全的。

abstract class AbstractTypeAttribute{
    private final int min, max;
    public AbstractTypeAttribute(int min, int max){
        //...
    }
    //...
}

class Body extends AbstractTypeAttribute{
    public Body(int min, int max){
        super(min, max);
        //...
    }
    //...
}

您应该考虑这样做而不是元属性和元类型。

更好的构建这个对象的模式？

2 个答案: