Java 对于表示比枚举更复杂但不完全是类的字段，什么是好的数据结构？

我正在编写一个与划船有关的程序，我正在创建一个名为“BoatType”的不可变类来表示不同类型的船。这变得越来越复杂，因为有许多类型需要唯一的描述

船型应具有以下特征：

• 双桨式或扫桨式
• 一个数字，即适合船上的人数
• 左舷或右舷类型，但仅当第一种类型为扫掠时
• 表示cox或uncox的布尔值，通常仅用于扫描

事实上，在赛艇世界中，只有这些领域的某些组合，这就更加复杂了。我希望我的程序能够轻松地枚举访问这些标准类型，而不必创建新的BoatType对象。这些文件全文如下：

划桨8
划桨4
双桨2
划桨1
扫掠8端口COXED
右后掠过8个船舷 扫掠4端口COXED
扫描4端口未固定
右后掠过4个甲板
右舷4号横扫未固定
扫掠2端口COXED
扫描2端口未固定
右后掠过2个甲板
右舷2号横扫未固定

目前这是我用Java编写的类：

public class BoatType
{
public enum RiggerType{SCULL, SWEEP_PORT, SWEEP_STARBOARD}

private int numSeats;

private RiggerType riggerType;

public boolean coxswain = true;

public BoatType(RiggerType type, int seats, boolean coxed)
{
    numSeats = seats;
    riggerType = type;
    coxswain = coxed;
}
}

通过枚举其他地方的标准类型：

    public static final BoatType 
    SCULL_OCTUPLE = new BoatType(RiggerType.SCULL, 8, false),
    SCULL_QUAD = new BoatType(RiggerType.SCULL, 4, false),
    SCULL_DOUBLE = new BoatType(RiggerType.SCULL, 2, false),
    SCULL_SINGLE = new BoatType(RiggerType.SCULL, 1, false),
    SWEEP_PORT_EIGHT_COXED  = new BoatType(RiggerType.SWEEP_PORT, 8, true),
    SWEEP_STARBOARD_EIGHT_COXED = new BoatType(RiggerType.SWEEP_STARBOARD, 8, true),
    SWEEP_PORT_FOUR_COXED = new BoatType(RiggerType.SWEEP_PORT, 4, true),
    SWEEP_PORT_FOUR_UNCOXED = new BoatType(RiggerType.SWEEP_PORT, 4, false),
    SWEEP_STARBOARD_FOUR_COXED = new BoatType(RiggerType.SWEEP_STARBOARD, 4, true),
    SWEEP_STARBOARD_FOUR_UNCOXED = new BoatType(RiggerType.SWEEP_STARBOARD, 4, false),
    SWEEP_PORT_PAIR_COXED = new BoatType(RiggerType.SWEEP_PORT, 2, true),
    SWEEP_PORT_PAIR_UNCOXED = new BoatType(RiggerType.SWEEP_PORT, 2, false),
    SWEEP_STARBOARD_PAIR_COXED = new BoatType(RiggerType.SWEEP_STARBOARD, 2, true),
    SWEEP_STARBOARD_PAIR_UNCOXED = new BoatType(RiggerType.SWEEP_STARBOARD, 2, false);

---

这目前看起来相当麻烦，所以我想知道是否有人对如何表示这一点有更好的想法。枚举是不可能的，因为虽然这些是现有的标准类型，但我不想将其限制为这些组合。

枚举实际上非常强大，可以处理您想要的复杂性。你确定这还不够复杂吗

---

我不明白这有多麻烦。事实就是这样，我不认为你会找到一个更干净的方法

---

请注意，您可能希望对

BoatType

的成员保持一致的可见性，并使所有成员成为最终成员。

我认为您的类基本上是好的，除了：

• 您应该将构造函数设置为私有的，并使用静态工厂函数，这些函数可以重用标准船类型的对象

• 您应该将标准类型的常量和集合放在类中，而不是放在其他地方

• 添加常用的基础结构（

  toString

  ，

  hashCode

  ，

  equals

  ，getter）

• 所有实例变量都应该是

  private

  （

  coxswain

  不是）和

  final

---

是的，这有点麻烦，但Java就是这样。像Eclipse这样的IDE可以通过生成一些代码来提供帮助。

您可以将BoatType抽象并创建BoatType的两个子类，即SculboatType和SweepBoatType。然后，您可以在SweepBoatType（但不在SculboatType）上定义两个布尔字段“isPort”和“isCoxed”。像这样：

abstract class BoatType {
    protected int numSeats;

    public BoatType(int numSeats) {
            this.numSeats = numSeats;
    }
}

final class ScullBoatType extends BoatType {
    public ScullBoatType(int numSeats) {
        super(numSeats);
    }
}

final class SweepBoatType extends BoatType {
    private boolean isPort;
    private boolean isCoxed;

    public SweepBoatType(int numSeats, boolean isPort, boolean isCoxed) {
        super(numSeats);
        this.isPort = isPort;
        this.isCoxed = isCoxed;
    }
}

然后可以按如下方式创建新实例：

BoatType SCULL_OCTUPLE = new ScullBoatType(8);
BoatType SWEEP_PORT_EIGHT_COXED = new SweepBoatType(8, true, true);
// and so on...

---

阅读问题的最后一句。考虑设计模式。封装变化的内容。赞成组合而不是继承。如果您能够阅读“头先设计模式”中的战略模式作为介绍。这并不完全是你所需要的，但会让你朝着更好的方向思考。（IMHO.：-）只要有有限数量的类型，enum就很好。所谓的“笨重”部分在我看来不错。