我需要创建一个需要表示以下内容的结构（对于类别和子类别）。它只有一层深。我正在考虑使用 Java Enums 来做这件事，但不确定如何表示这种层次结构。
代表设备的 java 对象（业务对象）将同时具有类别和子类别属性，我想使用枚举而不是使用整数代码，例如 100、1 等。有些设备只有类别，但没有子类别（如以下示例中的 300）。
100 Switch
1 Interior
2 Exterior
200 Security Sensor
1 Door Sensor
2 Leak Sensor
3 Motion Sensor
300 Camera
感谢任何帮助。
谢谢
【问题讨论】：
这篇java.dzone 文章展示了一个漂亮的分层枚举示例：
public enum OsType {
OS(null),
Windows(OS),
WindowsNT(Windows),
WindowsNTWorkstation(WindowsNT),
WindowsNTServer(WindowsNT),
Windows2000(Windows),
Windows2000Server(Windows2000),
Windows2000Workstation(Windows2000),
WindowsXp(Windows),
WindowsVista(Windows),
Windows7(Windows),
Windows95(Windows),
Windows98(Windows),
Unix(OS) {
@Override
public boolean supportsXWindows() {
return true;
}
},
Linux(Unix),
AIX(Unix),
HpUx(Unix),
SunOs(Unix),
;
private OsType parent = null;
private OsType(OsType parent) {
this.parent = parent;
}
}
本文展示了许多您可以通过此设置完成的小技巧。
【讨论】：
我认为this answer 对您来说是一个很好的解决方案。使用这样的类型层次结构：
public enum Component {
Interior(Part.Switch),
Exterior(Part.Switch),
DoorSensor(Part.SecuritySensor),
LeakSensor(Part.SecuritySensor),
MotionSensor(Part.SecuritySensor),
Camera(Part.Camera);
private final Part kindOf;
Component(Part kindOf) {
this.kindOf = kindOf;
}
enum Part {
Switch, SecuritySensor, Camera
}
}
更多细节可以在Effective Java 2nd Edition的章节枚举中找到。
【讨论】：
您想用枚举而不是继承来表达这一点似乎很不寻常。枚举的问题在于它们本质上是编译时常量，如果您想在层次结构中生成更多信息，则必须添加更多枚举。
这可能会变得混乱，很快。它也与枚举的真正目的略有矛盾——作为预定义的常量而不是分层实体。
我建议使用一个名为CategoryBase 的抽象类来绘制所有内容。然后，以此为基础创建您的继承树。
这是一个图表：
大部分工作实际上是保存属性，我们永远不会期望这些属性在创建后会被更改，因此我们可以让我们的抽象类来保存它们。我们也将它们设置为final，因此它们也无法修改。
public abstract class CategoryBase {
protected final int ranking;
protected final String name;
protected final SubCategory[] subCategories;
protected CategoryBase(int ranking, String name, SubCategory... subCategories) {
this.ranking = ranking;
this.name = name;
this.subCategories = subCategories;
}
public int getRanking() {
return ranking;
}
public String getName() {
return name;
}
public SubCategory[] getSubCategories() {
return subCategories;
}
}
从那里开始，我们可以以此为基础创建我们的标记类 - 包括 SubCategory，因为它实际上只是一个以不同方式表示的信息的持有者。
这也将使编写标记类变得简单明了。例如这里是Camera：
public class Camera extends CategoryBase {
protected Camera(int ranking, String name) {
super(ranking, name);
}
}
它与SubCategory 有着惊人的相似之处——SubCategory 没有任何嵌套的SubCategorys，因此我们不会向构造函数的可变参数部分传递任何内容。
对于确实有SubCategorys的东西，我们需要在构造时实例化它们。这里以SecuritySensor 为例。
public class SecuritySensor extends CategoryBase {
public SecuritySensor(int ranking, String name) {
super(ranking, name,
new SubCategory(1, "Door Sensor"),
new SubCategory(2, "Leak Sensor"),
new SubCategory(3, "Motion Sensor"));
}
}
这种方法也为您在排名方面提供了一些灵活性 - 如果您希望能够在运行时指定子类别的确切排名，您可以将此构造函数替换为支持可变参数的构造函数签名。
【讨论】：
您可以执行以下代码。但这可能不是您想要的。您可以将子枚举添加到父枚举的构造函数中，例如here。
enum Stuff {
Swich,Sensor,Camera;
enum swich {
interior,exterior;
enum Where {
bathroom,kitchen
}
}
enum sensor {
door,leak,motion
}
}
【讨论】：
也许重新考虑并在这里使用整数。但是，它们不是基于十进制系统（第一级为 100、200、300、...；第二级为 1、2、3、...），而是基于二进制表示。
// top-level
public static final int SWITCH = 1 << 16;
public static final int SECURITY_SENSOR = 2 << 16;
public static final int CAMERA = 4 << 16;
// sub-types of 'switch'
public static final int INTERIOR = SWITCH | 1;
public static final int EXTERIOR = SWITCH | 2;
// sub-types of 'security sensor'
public static final int DOOR_SENSOR = SECURITY_SENSOR | 1;
public static final int LEAK_SENSOR = SECURITY_SENSOR | 2;
public static final int MOTION_SENSOR = SECURITY_SENSOR | 4;
这允许您进行弱形式的继承测试：
if (value == SWITCH) {
// value is a switch, but not interior or exterior
} else if (value & SWITCH != 0) {
// value is interior or exterior
}
【讨论】：
以下代码是否满足您的要求？
public enum Category {Switch, ...}
public enum SubCategory {Interior, ...}
【讨论】：
Motion Sensor 不会存在于Switch 的值中...