构建该对象的更好模式？

发布于 2024-09-16 23:50:10 字数 782 浏览 4 评论 0原文

我正在构造具有如下数据结构

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) {
 }
}

的枚举值：每个 MetaType 指定一组固定的 MetaTypeAttributes，其中包含该属性的最小值和最大值。

我讨厌这种语法。它太长了，很难看，而且它并不能阻止我传入错误的 AttributeType（AttributeType 应与 MetaType 构造函数的参数顺序匹配；AttributeType.BODY > body 等）。我想要的是一个更好的模式来确保使用这种精确的方案构造对象。

这段代码是缩写的。实际上有 9 种 AttributeType。

有什么改进建议吗？

原文

I am constructing enum values that have a data structure like the following:

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) {
 }
}

So there is an enum of MetaTypes; each MetaType specifies a fixed set of MetaTypeAttributes, which consist of a min and max value for that attribute.

I hate this syntax. It's too long, it's ugly, and it doesn't prevent me from passing in the wrong AttributeType (the AttributeType should match up with the order of the arguments of MetaType's constructor; AttributeType.BODY > body, etc.). What I want is a better pattern for ensuring that an object is constructed with this exact scheme.

This code is abbreviated. In reality there are 9 AttributeTypes.

Any suggestions for improvement?

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

初心未许 2024-09-23 23:50:10

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

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

回复收藏 0 原文

美人如玉 2024-09-23 23:50:10

如果您考虑不同的属性类型，也许您应该真正将这些属性类型创建为类/子类而不是枚举。您将拥有 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);
        //...
    }
    //...
}

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

If you consider different attribute types, maybe you should really create those attribute types as classes/subclasses instead of enums. You will have all the advantages of OOP to handle the behavior of each type (inherited methods, method rewriting, ...) and they'll be type safe.

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

You should think about doing this instead of meta attributes and meta types too.

回复收藏 0 原文

~没有更多了~