Java的Boolean类-为什么不使用枚举？

在我看来，布尔类是作为枚举实现的理想候选者。

从源代码来看，大多数类都是静态方法，可以将其不变地移至枚举，其余的则变得像枚举一样简单。比较原始（删除注释和静态方法）：

public final class Boolean implements java.io.Serializable,
                                      Comparable<Boolean>
{
   public static final Boolean TRUE = new Boolean(true);
  public static final Boolean FALSE = new Boolean(false);
   private final boolean value;
   public Boolean(boolean value) {
       this.value = value;
   }
   public Boolean(String s) {
       this(toBoolean(s));
   }
   public boolean booleanValue() {
       return value;
   }
   public String toString() {
       return value ? "true" : "false";
   }
   public int hashCode() {
       return value ? 1231 : 1237;
   }
   public boolean equals(Object obj) {
       if (obj instanceof Boolean) {
           return value == ((Boolean)obj).booleanValue();
       }
       return false;
   }
   public int compareTo(Boolean b) {
       return compare(this.value, b.value);
   }
}

带有枚举版本：

public enum Boolean implements Comparable<Boolean>
{
   FALSE(false), TRUE(true);
   private Boolean(boolean value) {
       this.value = value;
   }
   private final boolean value;
   public boolean booleanValue() {
       return value;
   }

   public String toString() {
       return value ? "true" : "false";
   }
}

有什么理由使Boolean不能成为枚举？

如果这是要覆盖equals（）方法的Sun代码，则它缺少在比较两个对象的引用之前比较它们的值的非常根本的检查。这就是我认为equals（）方法应为的方式：

   public boolean equals(Object obj) {

       if (this == obj) {
          return true;
       }

       if (obj instanceof Boolean) {
           return value == ((Boolean)obj).booleanValue();
       }
       return false;
   }

好吧，我想我可以从争论开始，直到JDK 1.5才将 Java枚举添加到Java编程语言中。因此，在定义Boolean类的早期，这种解决方案甚至无法替代。

话虽这么说，Java的声誉是保持发行版之间的向后兼容性，所以即使我们今天认为您的解决方案是一个不错的选择，我们也无法做到这一点，而不必使用旧的Boolean来破坏数千行代码类。

当您将它们与Java的boolean的以前的功能进行比较时，有些事情是行不通的，并且以相当令人惊讶的方式行不通。

我们将忽略拳击，因为这是1.5的新增内容。假设，如果Sun希望，他们可以使enum Boolean行为就像在上执行拳击一样class Boolean。

然而，与早期类的功能相比，还有其他令人惊讶的方式（对于编码人员而言），这会突然中断。

valueOf（String）问题

一个简单的例子是：

public class BooleanStuff {
    public static void main(String args[]) {
        Boolean foo = Boolean.valueOf("TRUE");
        System.out.println(foo);
        foo = Boolean.valueOf("TrUe");
        System.out.println(foo);
        foo = Boolean.valueOf("yes");  // this is actually false
        System.out.println(foo);

        // Above this line is perfectly acceptable Java 1.3
        // Below this line takes Java 1.5 or later

        MyBoolean bar;
        bar = MyBoolean.valueOf("FALSE");
        System.out.println(bar);
        bar = MyBoolean.valueOf("FaLsE");
        System.out.println(bar);
    }

    enum MyBoolean implements Comparable<MyBoolean> {
        FALSE(false), TRUE(true);
        private MyBoolean(boolean value) { this.value = value; }
        private final boolean value;
        public boolean booleanValue() { return value; }
        public String toString() { return value ? "true" : "false"; }
    }
}

此代码的运行给出：

真正
真正
假
假
线程“主”中的异常java.lang.IllegalArgumentException：没有枚举常量BooleanStuff.MyBoolean.FaLsE
    在java.lang.Enum.valueOf（Enum.java:236）
    在BooleanStuff $ MyBoolean.valueOf（BooleanStuff.java:17）
    在BooleanStuff.main（BooleanStuff.java:13）

这里的问题是我无法通过任何不符合TRUE或不FALSE符合的内容valueOf(String)。

没关系...我们将使用自己的方法覆盖它...

    public static MyBoolean valueOf(String arg) {
        return arg.equalsIgnoreCase("true") ? TRUE : FALSE;
    }

但是...这里有问题。您不能覆盖静态方法。

因此，所有被绕过代码true或True或其他一些情况下混合时会报错了-和一个运行时异常相当壮观。

valueOf更有趣

还有一些其他方面效果不佳：

public static void main(String args[]) {
    Boolean foo = Boolean.valueOf(Boolean.valueOf("TRUE"));
    System.out.println(foo);

    MyBoolean bar = MyBoolean.valueOf(MyBoolean.valueOf("FALSE"));
    System.out.println(bar);
}

对于foo，我只是收到关于装箱一个已经装箱的值的警告。但是，bar的代码是语法错误：

错误：（7，24）Java：找不到适合valueOf（BooleanStuff.MyBoolean）的方法
    方法BooleanStuff.MyBoolean.valueOf（java.lang.String）不适用
      （无法通过方法调用转换将实际参数BooleanStuff.MyBoolean转换为java.lang.String）
    方法java.lang.Enum.valueOf（java.lang.Class，java.lang.String）不适用
      （由于实际和正式参数列表的长度不同，因此无法从参数实例化）

如果我们将语法错误强制转换为String类型：

public static void main(String args[]) {
    Boolean foo = Boolean.valueOf(Boolean.valueOf("TRUE"));
    System.out.println(foo);

    MyBoolean bar = MyBoolean.valueOf(MyBoolean.valueOf("FALSE").toString());
    System.out.println(bar);
}

我们返回运行时错误：

真正
线程“主”中的异常java.lang.IllegalArgumentException：没有枚举常量BooleanStuff.MyBoolean.false
    在java.lang.Enum.valueOf（Enum.java:236）
    在BooleanStuff $ MyBoolean.valueOf（BooleanStuff.java:11）
    在BooleanStuff.main（BooleanStuff.java:7）

为什么有人会写那个？Dunno ...但是它的代码曾经有效，将不再起作用。

不要误会我的意思，我真的很喜欢给定的不变对象只有一个副本的想法。枚举确实解决了这个问题。我亲自遇到了供应商代码，其中的供应商代码看起来像这样：

if(boolValue == new Boolean("true")) { ... }

这从来没有工作_{^{（不，我没有，因为不正确的状态是固定的其他地方，并确定这打破了以奇怪的方式，我真的没有时间去调试解决它）}}。如果这是一个枚举，则该代码将起作用。

但是，围绕枚举的语法的必要性（区分大小写-深入探究其背后的enumConstantDirectoryvalueOf，对于其他枚举而言需要以这种方式工作的运行时错误）以及静态方法的工作方式会导致很多事情中断，从而阻止它被替换为布尔值。

最有可能的原因是原始boolean类型不是Enum，并且装箱版本的原始类型的行为几乎与未装箱版本的行为相同。例如

Integer x = 5;
Integer y = 7;
Integer z = x + y;

（性能可能不尽相同，但这是不同的主题。）

如果您能写的话，那会有些奇怪：

Boolean b = Boolean.TRUE;
switch (b) {
case Boolean.TRUE:
    // do things
    break;
case Boolean.FALSE:
    // do things
    break;
}

但不是：

boolean b = true;
switch(b) {
case true:
    // do things
    break;
case false:
    // do things
    break;
}  

除了valueOf问题（这是Java级别的问题，它在JVM级别上可以正常工作）之外，这还因为Boolean它具有公共构造函数。这是一个坏主意，目前已被弃用，但这是可以保留的主意。

原因是“布尔”早于“枚举”是Java语言的一部分。多年来，非常希望拥有“布尔”，而没有“枚举”。只是现在您可以说“如果从一开始就可以使用枚举，那么我们可以将bool作为枚举而不是单独的类型来实现”。

在Swift中，可以将“ bool”表示为枚举，其中有三个结构分别实现了“ ExpressibleByBooleanLiteral”协议的“ Bool”，“ DarwinBoolean”和“ ObjCBool​​”结构。（DarwinBoolean与C或C ++ bool兼容，ObjCBool​​与Objective-C BOOL兼容）。“ true”和“ false”是编译器可识别的特殊值，并且只能用于初始化支持“ ExpressibleByBooleanLiteral”协议的对象。布尔有一个内部变量“ _value”，其中包含一位整数。

因此，布尔不是Swift语言的一部分，而是标准库的一部分。true和false是语言的一部分，ExpressibleByBooleanLiteral协议也是如此。