Alternative zu enum in Java 1.4

Question

Da Java 1.4 keine Enums hat, mache ich etwas in dieser Art:

public class SomeClass {
     public static int SOME_VALUE_1 = 0;
     public static int SOME_VALUE_2 = 1;
     public static int SOME_VALUE_3 = 2;

     public void receiveSomeValue(int someValue) {
            // do something
     }
 }

Der Aufrufer von receiveSomeValue sollte einen dieser 3 Werte übergeben, er kann aber auch jeden anderen int übergeben. Wäre es ein Enum, könnte der Aufrufer nur einen gültigen Wert übergeben.

Sollte receiveSomeValue eine InvalidValueException auslösen?

Was sind gute Alternativen zu Java 5 Enums?

Answer 1

Für die Zeit vor 1.5 ist die Typsichere Enum-Muster am besten beschrieben in dem Buch Effektives Java von Josh Bloch . Es hat jedoch einige Einschränkungen, vor allem wenn Sie mit verschiedenen Classloadern, Serialisierung und so weiter zu tun haben.

Sie können auch einen Blick auf das Apache Commons Lang Projekt werfen und insbesondere auf die enum Klasse, wie John geschrieben hat. Sie ist eine Implementierung dieses Musters und unterstützt die Erstellung eigener Enums.

Answer 2

Normalerweise würde ich eine so genannte konstante Klasse erstellen, etwa so:

public class MyConstant 
{
  public static final MyConstant SOME_VALUE = new MyConstant(1);
  public static final MyConstant SOME_OTHER_VALUE = new MyConstant(2);
  ...

  private final int id;

  private MyConstant(int id)
  {
    this.id = id;
  }

  public boolean equal(Object object) 
  {
    ...
  }

  public int hashCode() 
  {
    ...
  }
}

donde equals y hashCode verwenden die id .

Answer 3

Apache Commons Lang hat eine Enum-Klasse das gut funktioniert und ziemlich gut abdeckt, was Java 5 Enums bieten.

Answer 4

Wenn die Anwendung Code-Basis wird viel Enums verwenden, dann würde ich folgende Lösung bevorzugen, die ich in meiner Anwendung verwendet haben.

Basisklasse

public class Enum {
    protected int _enumValue;
    protected Enum(int enumValue) {
        this._enumValue = enumValue;
    }

    public int Value() {
        return this._enumValue;
    }
}

Ihre Aufzählungen werden dann nach folgendem Muster erfolgen

Tatsächliches Enum

public class DATE_FORMAT extends Enum {
    public static final int DDMMYYYY = 1;
    public static final int MMDDYYYY = 2;
    public static final int YYYYMMDD = 3;

    public DATE_FORMAT(int enumValue) {
        super(enumValue);
    }
}

Und Ihr Code kann diese Aufzählung wie folgt verwenden

String getFormattedDate(DATE_FORMAT format) {

    String sDateFormatted = "";

    switch (format.Value()) {

        case DATE_FORMAT.DDMMYYYY : 
            break;
        case DATE_FORMAT.MMDDYYYY :
            break;
        case DATE_FORMAT.YYYYMMDD :
            break;
        default:
            break;
    }

    return sDateFormatted;
}

Der Aufrufer kann die Funktion als

void callerAPI() {
    DATE_FORMAT format = new DATE_FORMAT(DATE_FORMAT.DDMMYYYY);

    String sFormattedDate = getFormattedDate(format);

}

Dies ist noch kein vollständiger Beweis gegen die Intitialisierung von abgeleiteten Enum-Objekten mit einem beliebigen Integer-Wert. Es kann jedoch eine gute syntaktische Leitlinie für die Arbeit in einer Nicht-Enum-Umgebung bieten.