Java 对于下面提到的情况，哪一个是更好的选择接口或枚举？

Herbert Schildt提到，虽然这些方法在技术上没有问题， 枚举是一个更好的选择

考虑以下几点：

选择1：

//列举可能的答案

enum Answers {
    NO, YES, MAYBE, LATER, SOON, NEVER
}


public class Question {
    Random rand = new Random();

  Answers ask() {
    int prob = (int) (100 * rand.nextDouble());
    if (prob < 15)
        return Answers.MAYBE; // 15%
    else if (prob < 30)
        return Answers.NO; // 15%
    else if (prob < 60)
        return Answers.YES; // 30%
    else if (prob < 75)
        return Answers.LATER; // 15%
    else if (prob < 98)
        return Answers.SOON; // 13%else
    return Answers.NEVER; // 2%
   }
 }


public class AskMe {
  static void answer(Answers result) {
    switch (result) {
    case NO:
        System.out.println("No");
        break;
    case YES:
        System.out.println("Yes");
        break;
    case MAYBE:
        System.out.println("Maybe");
        break;
    case LATER:
        System.out.println("Later");
        break;
    case SOON:
        System.out.println("Soon");
        break;
    case NEVER:
        System.out.println("Never");
        break;
    }
}

public static void main(String args[]) {
    Question q = new Question();
    answer(q.ask());
    answer(q.ask());
    answer(q.ask());
    answer(q.ask());
}

enum答案{
不，是的，也许，以后，很快，永远不会
}
公开课问题{
Random rand=新的Random（）；
答案问（）{
int prob=（int）（100*rand.nextDouble（））；
如果（概率<15）
返回答案。可能；//15%
否则如果（概率<30）
返回答案。否；//15%
否则如果（概率<60）
返回答案。是；//30%
否则如果（概率<75）
返回答案。稍后；//15%
否则如果（概率<98）
返回答案。很快；//其他13%
返回答案。从不；//2%
}
}
公共类AskMe{
静态无效答案（答案结果）{
开关（结果）{
案件编号：
系统输出打印项次（“否”）；
打破
案例是：
System.out.println（“是”）；
打破
案例可能：
System.out.println（“可能”）；
打破
稍后个案：
System.out.println（“以后”）；
打破
即将审理的案件：
System.out.println（“很快”）；
打破
案例从不：
System.out.println（“从不”）；
打破
}
}
公共静态void main（字符串参数[]）{
问题q=新问题（）；
回答（问）；
回答（问）；
回答（问）；
回答（问）；
}

}

选择2：

public interface SharedConstants {
   int NO = 0;
   int YES = 1;
   int MAYBE = 2;
   int LATER = 3;
   int SOON = 4;
   int NEVER = 5;
}


public class Question implements SharedConstants {

    Random rand = new Random();

   int ask() {
    int prob = (int) (100 * rand.nextDouble());
    if (prob < 30)
        return NO; // 30%
    else if (prob < 60)
        return YES; // 30%
    else if (prob < 75)
        return LATER; // 15%
    else if (prob < 98)
        return SOON; // 13%
    else
        return NEVER; // 2%
  }
}

public class AskMe implements SharedConstants {

   static void answer(int result) {
    switch (result) {
    case NO:
        System.out.println("No");
        break;
    case YES:
        System.out.println("Yes");
        break;
    case MAYBE:
        System.out.println("Maybe");
        break;
    case LATER:
        System.out.println("Later");
        break;
    case SOON:
        System.out.println("Soon");
        break;
    case NEVER:
        System.out.println("Never");
    }
}

public static void main(String args[]) {
    Question q = new Question();
    answer(q.ask());
    answer(q.ask());
    answer(q.ask());
    answer(q.ask());
 }
}

公共接口共享实例{
int NO=0；
int YES=1；
int=2；
int=3；
int-SOON=4；
int=5；
}
公共类问题实现了SharedConstants{
Random rand=新的Random（）；
int ask（）{
int prob=（int）（100*rand.nextDouble（））；
如果（概率<30）
返回否；//30%
否则如果（概率<60）
返回YES；//30%
否则如果（概率<75）
稍后返回；//15%
否则如果（概率<98）
马上回来；//13%
其他的
从不返回；//2%
}
}
公共类AskMe实现SharedConstants{
静态无效答案（整数结果）{
开关（结果）{
案件编号：
系统输出打印项次（“否”）；
打破
案例是：
System.out.println（“是”）；
打破
案例可能：
System.out.println（“可能”）；
打破
稍后个案：
System.out.println（“以后”）；
打破
即将审理的案件：
System.out.println（“很快”）；
打破
案例从不：
System.out.println（“从不”）；
}
}
公共静态void main（字符串参数[]）{
问题q=新问题（）；
回答（问）；
回答（问）；
回答（问）；
回答（问）；
}
}

赫伯特·席尔德没有给出同样的理由。

---

我不明白为什么关于枚举的选择更好？

误用一个通用的数字类型，例如

int

作为枚举从来都不是一个好主意。在java中考虑使用它的唯一原因是性能，当我说性能时，我指的是纳秒。

---

如果采用

int

方法，您会损失很多：

enum

是一个成熟的类，可以有任意方法，从而简化和组织代码。您还可以获得完整类型的安全性。事实上，优点如此之多，如果我尝试将它们全部列举出来，这个答案会变得太长。

误用一个通用的数字类型，例如

int

，作为一个枚举从来都不是一个好主意。在java中考虑使用它的唯一原因是性能，当我说性能时，我指的是纳秒。

---

如果采用

int

方法，您会损失很多：

enum

是一个成熟的类，可以有任意方法，从而简化和组织代码。您还可以获得完整类型的安全性。事实上，优势如此之多，如果我试图一一列举，这个答案会变得太长。

你可以更自信地知道所有可能的值是什么。例如，在执行

int

版本时，您删除了其中一个选项

您还可以包含或封装更多信息，而不是通过代码分发

enum Answers {
    NO("No", 0.30),
    YES(Yes", 0.30),
    MAYBE("Maybe", 0.15),
    LATER("Later", 0.15),
    SOON("Soon", 0.13),
    NEVER("Never", 0.02);

    private final String description;
    private final double chance;

    private Answer(String description, double chance) {
        this.description = description;
        this.chance = chance;
    }

    public String getDescription() { return description; }

    public Answers getRandom() {
        double r = Math.random();
        for(Answer a : values())
           if ((r -= a.chance) <= 0)
               return a;
        return NEVER;
    }
}

enum答案{
否（“否”，0.30），
是（是），0.30，
可能（“可能”，0.15），
后来（“后来”，0.15），
很快（“很快”，0.13），
从不（“从不”，0.02）；
私有最终字符串描述；
私人最终双重机会；
私人答案（字符串描述，双机会）{
this.description=描述；
这个机会=机会；
}
公共字符串getDescription（）{return description；}
公共答案getRandom（）{
double r=Math.random（）；
对于（答案a:values（））
如果（（r-=a.chance）您可以更自信地知道所有可能的值是什么。例如，当您执行
int
版本时，您删除了其中一个选项

您还可以包含或封装更多信息，而不是通过代码分发

enum Answers {
    NO("No", 0.30),
    YES(Yes", 0.30),
    MAYBE("Maybe", 0.15),
    LATER("Later", 0.15),
    SOON("Soon", 0.13),
    NEVER("Never", 0.02);

    private final String description;
    private final double chance;

    private Answer(String description, double chance) {
        this.description = description;
        this.chance = chance;
    }

    public String getDescription() { return description; }

    public Answers getRandom() {
        double r = Math.random();
        for(Answer a : values())
           if ((r -= a.chance) <= 0)
               return a;
        return NEVER;
    }
}

enum答案{
否（“否”，0.30），
是（是），0.30，
可能（“可能”，0.15），
后来（“后来”，0.15），
很快（“很快”，0.13），
从不（“从不”，0.02）；
私有最终字符串描述；
私人最终双重机会；
私人答案（字符串描述，双机会）{
this.description=描述；
这个机会=机会；
}
公共字符串getDescription（）{return description；}
公共答案getRandom（）{
double r=Math.random（）；
对于（答案a:values（））
如果（（r-=a.chance）我无法解释第一段。我无法解释您的评论：）什么让你不安？我的意思是，使用它的唯一原因只是因为基于纳秒的性能。是的，这是事实。你不同意吗？我正在开发一个贷款申请银行应用程序，但设计师从未与我沟通过使用它们，甚至一次也没有。它们是很少使用，还是我的团队没有意识到使用它们的力量1.我无法解释