Question

我有一个包含以下方案的枚举：

public enum Enum{
    A,
    B,
    C,
    D
    //...
}

在另一个课程中，我根据此枚举计算score。

我应该使用哪种方法？为什么？

解决方案1：

我使用switch语句：

public int score(Enum value)
{
    switch(value){
        case Enum.A:
            this.score *= 25;
            break;
        case Enum.B: 
            this.score *= 7;
            break;
        case Enum.C:
            this.score *= 2;
            break;
        //...
    }
    return this.score;
}

解决方案2：

我在我的Enum 中添加了一个变量：

public enum Enum{
    A(25),
    B(7),
    C(2),
    D(16),
    //...
    Z(100);

    private final int scoreMultiplier;

    Enum(int scoreMultiplier){
        this.scoreMultiplier = scoreMultiplier;
    }

    public int getScoreMultiplier(){return scoreMultiplier;}
}

然后，我的得分方法：

public int score(Enum value)
{
    this.score *= value.getScoreMultiplier();
    return this.score;
}

Answer 1

这是另一种选择：访客模式。

定义访客界面：

public interface Visitor<RESULT> {
    RESULT visitA(ABCD a);

    RESULT visitB(ABCD b);

    RESULT visitC(ABCD c);

    RESULT visitD(ABCD d);
}

让你的枚举接受访问者：

public enum ABCD {
    A {
        @Override
        public <RESULT> RESULT accept(Visitor<RESULT> visitor) {
            return visitor.visitA(this);
        }
    },
    B {
        @Override
        public <RESULT> RESULT accept(Visitor<RESULT> visitor) {
            return visitor.visitB(this);
        }
    },
    C {
        @Override
        public <RESULT> RESULT accept(Visitor<RESULT> visitor) {
            return visitor.visitC(this);
        }
    },
    D {
        @Override
        public <RESULT> RESULT accept(Visitor<RESULT> visitor) {
            return visitor.visitD(this);
        }
    };

    public abstract <RESULT> RESULT accept(Visitor<RESULT> visitor);
}

不，您可以将基于枚举的功能捕获为访问者。例如，计算得分：

public static int score(ABCD abcd) {
    return abcd.accept(new Visitor<Integer>() {
        @Override
        public Integer visitA(ABCD a) {
            return 25;
        }
        @Override
        public Integer visitB(ABCD b) {
            return 7;
        }
        @Override
        public Integer visitC(ABCD c) {
            return 2;
        }

        @Override
        public Integer visitD(ABCD d) {
            return 16;
        }
    });
}

从某一方面来说，这提供了一定的安全性，即如果添加新的枚举项，则需要使用新的visitX方法扩展访问者界面，从而扩展所有现有的访问者实现。

另一方面，您不会使用要在枚举上执行的操作的语义来污染您的枚举。如果您需要为枚举添加更多功能，则无需对其进行扩展。只需编写新的访问者实现。

切换语句与枚举变量

1 个答案: