重新设计进度价值层次

Question

我有几个调度值类，它们表示计划对特定时隙的值。

首先，有用于二维调度的ScheduleValue类，其中第一个(行)是玩家，第二个(列)是时隙(当球员每场比赛时)。

我用公共静态ints表示不同的可能值，这就是用来实例化一个新ScheduleValue的方法：

public class ScheduleValue {
    public static int OCCUPIED = 1;
    public static int FREE = 2;
    public static int UNAVAILABLE = 3;
    public static int BREAK = 4;
    public static int LIMITED = 5;
    public static int NOT_IN_DOMAIN = 6;

    private int value;

    public ScheduleValue(int val) {
        value = val;
    }
}

但是，有一个特殊的值OCCUPIED，它要求传递一个整数，因此匹配位置所在的本地化(法院)由调度值表示。因此，我添加了另一个构造函数，并被迫添加控件以防止出现错误的状态：

public ScheduleValue(int val) {
    if (!(val >= OCCUPIED && val <= NOT_IN_DOMAIN))
        throw new IllegalArgumentException("Illegal value (" + val + ")");

    if (val == OCCUPIED)
        throw new IllegalArgumentException("A localization must be specified if the schedule value is OCCUPIED");

    value = val;
}

public ScheduleValue(int val, int l) {
    if (!(val >= OCCUPIED && val <= NOT_IN_DOMAIN))
        throw new IllegalArgumentException("Illegal value (" + val + ")");

    if (val != OCCUPIED)
        throw new IllegalArgumentException("Only schedule values of OCCUPIED can specify a localization");

    value = val;
    localization = l;
}

我真的不喜欢我这样做。必须抛出异常和检查值的方式(使用关系操作，而不是检查它们是否包含在允许的值列表中)。我怎么能重新设计呢？我是否应该仅仅为了保存本地化的值而创建一个ScheduleValueOccupied类？

然后，我还有一个LocalizationScheduleValue，它是为另一种类型的时间表创建的，其中第一个维度是进行比赛的局部化，而不是球员(因此矩阵是按时隙而不是按时隙进行的)。虽然它看起来很像ScheduleValue，但它甚至没有扩展到它：

public class LocalizationScheduleValue {
    public static int OCCUPIED = 1;
    public static int FREE = 2;
    public static int UNAVAILABLE = 3;
    public static int LIMITED = 4;
    public static int CONTINUATION = 5;
    private int value;
    private List<Integer> playersIndices;

    public LocalizationScheduleValue(int val) {
        if (!(val >= OCCUPIED && val <= CONTINUATION))
            throw new IllegalArgumentException("Illegal value (" + val + ")");

        if (val == OCCUPIED)
            throw new IllegalStateException("A match must be specified if the schedule value is OCCUPIED");

        value = val;
    }

    public LocalizationScheduleValue(int val, List<Integer> indices) {
        if (!(val >= OCCUPIED && val <= CONTINUATION))
            throw new IllegalArgumentException("Illegal value (" + val + ")");

        if (val != OCCUPIED)
            throw new IllegalStateException("Only schedule values of OCCUPIED can specify a match taking place");

        value = val;
        playersIndices = indices;
    }
}

我想更改这个类，以便它与ScheduleValue相关，但是我不知道如何更改这个类，因为我要提到的原因是。

我主要关心的是我在内部表示值的方式，我应该坚持整数，还是应该改为枚举呢？

然后，创建一个新的层次结构。如果我最后有一个ScheduleValue、ScheduleValueOccupied、LocalizationScheduleValue和LocalizationScheduleValueOccupied，我如何表示所有可能的值？如果我使用in，我必须跟踪我在父程序中使用的数字，否则就会发生冲突；例如：

public class ScheduleValue {
    public static int OCCUPIED = 1;
    // ...
}

public class LocalizationScheduleValue extends ScheduleValue {
    public static int OCCUPIED = 1; // clash with parent here
    // ...
}

而如果我使用枚举，我如何才能继承其中的一部分，并附加一些更多的价值？示例：

public class ScheduleValue {
    protected enum Value { OCCUPIED, FREE, UNAVAILABLE, BREAK, LIMITED, NOT_IN_DOMAIN };
    // ...
}

public class LocalizationScheduleValue extends ScheduleValue {
    // I would only want OCCUPIED, FREE and UNAVAILABLE, but not the rest
    // and I would need to add to the possible values LIMITED and CONTINUATION
}

我对如何重组整件事情感到非常困惑，尤其是关于内部代表及其继承的问题。也有冗余的名字，我怎么能命名枚举呢？

也许我想得太多了，解决办法比我想象的要简单。我希望这是你说的一次，我怎么能不看到这个呢？

有什么建议吗？

Answer 1

您可以选择在示例中使用类而不是int或enum。(我没有用Java编程，所以如果语法错误请原谅)

public interface Value{
}
public interface LocalizationValue implements Value{
}
public class Occupied implements LocalizationValue{
}
public class Free implements LocalizationValue{
}
public class Limited implements Value{
}
//...

这样，您就可以确保构造器只能接受正确的类型：

public ScheduleValue( Value val ){ 
     //...
}
public LocalizationScheduleValue( LocalizationValue val ){
     //...
}

当然，您不应该只保留这个类为空。他们现在是真正的课程，应该开始承担一些责任。例如，让我们声明在代码库中有几个类似于此的if/ lets语句：

public void doSomething( Value val ){
    if( val == OCCUPIED ){
         doSomethingOccupied();
    else if( val == FREE ){
         soSomethingFree();
    }
    //...
}

现在不再需要这些开关了，因为您可以在值接口中定义doSomething()并在具体的类中实现它。

public interface Value{
    public void doSomething();
}
public class Occupied implements Value{
    public void doSomething(){
        //...
    }
}
public class Free implements Value{
    public void doSomething(){
        //...
    }
}
//...

public void doSomething( Value val ){
    val.doSomething();
}

当在值类中实现doSomething方法没有意义时，可以使用访问者模式提取它。我不会为此键入代码片段，但是如果您不知道，应该查找访问者模式。这样做更安全，因为如果要添加另一种值类型，编译器会一直抱怨，直到实现了正确的函数。