Javas Boolesche Klasse - warum nicht eine Aufzählung?

Es scheint mir, dass die Boolesche Klasse ein idealer Kandidat ist, um als Aufzählung implementiert zu werden.

Mit Blick auf den Quellcode besteht der größte Teil der Klasse aus statischen Methoden, die unverändert in eine Aufzählung verschoben werden können. Der Rest wird als Aufzählung viel einfacher. Original vergleichen (Kommentare und statische Methoden entfernt):

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);
   }
}

mit einer Enum-Version:

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";
   }
}

Gibt es einen Grund, warum Boolean keine Aufzählung werden konnte?

Wenn dies der Sun-Code zum Überschreiben der equals () -Methode ist, fehlt eine sehr grundlegende Überprüfung des Vergleichs der Referenzen der beiden Objekte vor dem Vergleich ihrer Werte. So sollte meiner Meinung nach die equals () -Methode sein:

   public boolean equals(Object obj) {

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

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

Nun, ich denke, ich könnte damit beginnen, zu argumentieren, dass der Java-Programmiersprache erst mit JDK 1.5 Java-Aufzählungen hinzugefügt wurden . und deshalb war diese Lösung in den frühen Tagen, als die Boolesche Klasse definiert wurde, nicht einmal eine Alternative.

Abgesehen davon hat Java den Ruf, die Abwärtskompatibilität zwischen Releases aufrechtzuerhalten. Selbst wenn wir Ihre Lösung heute als gute Alternative betrachten, können wir dies nicht tun, ohne Tausende von Codezeilen zu unterbrechen, die bereits den alten Booleschen Wert verwenden Klasse.

Es gibt einige Dinge, die nicht funktionieren und nicht auf überraschende Weise funktionieren, wenn Sie sie mit früheren Funktionen von Javas Booleschem Wert vergleichen.

Wir werden das Boxen ignorieren, da dies mit 1.5 hinzugefügt wurde. Wenn Sun wollte, hätten sie das hypothetisch dazu bringen können, enum Booleansich genauso zu verhalten wie das Boxen, das am class Boolean.

Es gibt jedoch andere überraschende (für den Codierer) Möglichkeiten, wie dies im Vergleich zur Funktionalität der früheren Klasse plötzlich brechen würde.

Das Problem valueOf (String)

Ein einfaches Beispiel hierfür ist:

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"; }
    }
}

Der Lauf dieses Codes ergibt:

wahr
wahr
falsch
falsch
Ausnahme im Thread "main" java.lang.IllegalArgumentException: Keine Enum-Konstante BooleanStuff.MyBoolean.FaLsE
    at java.lang.Enum.valueOf (Enum.java:236)
    bei BooleanStuff $ MyBoolean.valueOf (BooleanStuff.java:17)
    bei BooleanStuff.main (BooleanStuff.java:13)

Das Problem hier ist , dass ich nichts passieren kann , der nicht ist TRUEoder FALSEzu valueOf(String).

Das ist in Ordnung ... wir überschreiben es einfach mit unserer eigenen Methode ...

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

Aber ... hier gibt es ein Problem. Sie können eine statische Methode nicht überschreiben .

Und so, die alle Code, um vergehen trueoder Trueoder ein anderer Fall gemischt werden Fehler aus - und ganz spektakulär mit einer Laufzeit Ausnahme.

Noch mehr Spaß mit valueOf

Es gibt einige andere Teile, die nicht so gut funktionieren:

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);
}

Denn fooich bekomme nur eine Warnung über das Boxen eines bereits verpackten Wertes. Der Code für bar ist jedoch ein Syntaxfehler:

Fehler: (7, 24) Java: Keine geeignete Methode für valueOf gefunden (BooleanStuff.MyBoolean)
    Die Methode BooleanStuff.MyBoolean.valueOf (java.lang.String) ist nicht anwendbar
      (Das eigentliche Argument BooleanStuff.MyBoolean kann nicht durch Konvertierung des Methodenaufrufs in java.lang.String konvertiert werden.)
    Die Methode java.lang.Enum.valueOf (java.lang.Class, java.lang.String) ist nicht anwendbar
      (Kann nicht anhand von Argumenten instanziiert werden, da die tatsächlichen und formalen Argumentlisten unterschiedlich lang sind.)

Wenn wir diesen Syntaxfehler zurück in einen StringTyp zwingen :

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);
}

Wir bekommen unseren Laufzeitfehler zurück:

wahr
Ausnahme im Thread "main" java.lang.IllegalArgumentException: Keine Enum-Konstante BooleanStuff.MyBoolean.false
    at java.lang.Enum.valueOf (Enum.java:236)
    bei BooleanStuff $ MyBoolean.valueOf (BooleanStuff.java:11)
    bei BooleanStuff.main (BooleanStuff.java:7)

Warum sollte jemand das schreiben? Keine Ahnung ... aber sein Code, der früher funktionierte und nicht mehr funktionierte.

Versteh mich nicht falsch, ich mag wirklich die Idee, immer nur eine Kopie eines bestimmten unveränderlichen Objekts zu haben. Die Aufzählung löst dieses Problem. Ich bin persönlich auf Herstellercode gestoßen, der Fehler im Herstellercode enthielt, der ungefähr so ​​aussah:

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

das hat nie funktioniert _{^{(Nein, ich habe es nicht behoben, weil der falsche Status woanders behoben wurde, und das Beheben dieses Problems hat das auf seltsame Weise gebrochen, dass ich wirklich keine Zeit zum Debuggen hatte)}} . Wenn dies eine Aufzählung wäre, hätte dieser Code stattdessen funktioniert.

Die Notwendigkeit der Syntax rund um die Aufzählung (Groß- und Kleinschreibung beachten - in das dahinter stehende enumConstantDirectory eintauchenvalueOf , Laufzeitfehler, die für die anderen Aufzählungen auf diese Weise funktionieren müssen) und die Art und Weise, wie statische Methoden funktionieren, führen jedoch dazu, dass eine Reihe von Dingen beschädigt werden, die dies verhindern ein Tropfen auf den Ersatz für einen Booleschen.

Höchstwahrscheinlich, weil der primitive booleanTyp kein Enumist und sich die Box-Versionen der primitiven Typen fast identisch mit ihrer Unbox-Version verhalten. Z.B

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

(Die Leistung ist möglicherweise nicht dieselbe, aber das ist ein anderes Thema.)

Es wäre seltsam, wenn Sie schreiben könnten:

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

aber nicht:

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

Zusätzlich zum valueOfProblem (das ein Problem auf Java-Ebene ist, könnte es auf JVM-Ebene gut funktionieren) liegt es daran, dass Booleanes einen öffentlichen Konstruktor hat. Das war eine schlechte Idee, die derzeit veraltet ist, aber sie ist hier, um zu bleiben.

Der Grund ist, dass "bool" viel früher als "enum" Teil der Java-Sprache war. Für viele Jahre war "bool" sehr wünschenswert, während "enum" nicht verfügbar war. Erst jetzt können Sie sagen: "Wenn Enum von Anfang an verfügbar gewesen wäre, hätten wir Bool als Enum anstelle eines separaten Typs implementieren können."

In Swift, das "bool" als Aufzählung hätte ausdrücken können, gibt es drei Strukturen mit den Namen "Bool", "DarwinBoolean" und "ObjCBool", die das Protokoll "ExpressibleByBooleanLiteral" implementieren. (DarwinBoolean ist kompatibel mit einem C- oder C ++ - Bool, ObjCBool ​​ist kompatibel mit einem Objective-C-BOOL). "true" und "false" sind vom Compiler erkannte Sonderwerte und können nur zum Initialisieren von Objekten verwendet werden, die das Protokoll "ExpressibleByBooleanLiteral" unterstützen. Bool hat eine interne Variable "_value", die eine 1-Bit-Ganzzahl enthält.

Bool ist also nicht Teil der Swift-Sprache, sondern der Standardbibliothek. true und false sind Teil der Sprache, ebenso wie das ExpressibleByBooleanLiteral-Protokoll.