Kann ich den Enum-Startwert in Java festlegen?

Ich benutze die Aufzählung, um ein paar Konstanten zu machen:

enum ids {OPEN, CLOSE};

Der OPEN-Wert ist Null, aber ich möchte ihn als 100. Ist es möglich?

Java-Enums sind nicht wie C- oder C ++ - Enums, die eigentlich nur Bezeichnungen für Ganzzahlen sind.

Java-Enums werden eher wie Klassen implementiert - und sie können sogar mehrere Attribute haben.

public enum Ids {
    OPEN(100), CLOSE(200);

    private final int id;
    Ids(int id) { this.id = id; }
    public int getValue() { return id; }
}

Der große Unterschied besteht darin, dass sie typsicher sind, sodass Sie sich keine Gedanken über die Zuweisung einer COLOR-Enumeration zu einer SIZE-Variablen machen müssen.

Weitere Informationen finden Sie unter http://docs.oracle.com/javase/tutorial/java/javaOO/enum.html .

Ja. Sie können die numerischen Werte wie folgt an den Konstruktor für die Aufzählung übergeben:

enum Ids {
  OPEN(100),
  CLOSE(200);

  private int value;    

  private Ids(int value) {
    this.value = value;
  }

  public int getValue() {
    return value;
  }
}

Weitere Informationen finden Sie im Sun Java Language Guide .

Was ist mit dieser Methode:

public enum HL_COLORS{
          YELLOW,
          ORANGE;

          public int getColorValue() {
              switch (this) {
            case YELLOW:
                return 0xffffff00;
            case ORANGE:
                return 0xffffa500;    
            default://YELLOW
                return 0xffffff00;
            }
          }
}

Es gibt nur eine Methode.

Sie können die statische Methode verwenden und die Aufzählung als Parameter wie folgt übergeben:

public enum HL_COLORS{
          YELLOW,
          ORANGE;

          public static int getColorValue(HL_COLORS hl) {
              switch (hl) {
            case YELLOW:
                return 0xffffff00;
            case ORANGE:
                return 0xffffa500;    
            default://YELLOW
                return 0xffffff00;
            }
          }

Beachten Sie, dass diese beiden Methoden weniger Speicher und mehr Prozesseinheiten verbrauchen. Ich sage nicht, dass dies der beste Weg ist, aber es ist nur ein anderer Ansatz.

Wenn Sie sehr große Aufzählungstypen verwenden, kann Folgendes hilfreich sein.

public enum deneme {

    UPDATE, UPDATE_FAILED;

    private static Map<Integer, deneme> ss = new TreeMap<Integer,deneme>();
    private static final int START_VALUE = 100;
    private int value;

    static {
        for(int i=0;i<values().length;i++)
        {
            values()[i].value = START_VALUE + i;
            ss.put(values()[i].value, values()[i]);
        }
    }

    public static deneme fromInt(int i) {
        return ss.get(i);
    }

    public int value() {
    return value;
    }
}

Wenn Sie eine Aufzählung von C / C ++ emulieren möchten (Basisnummern und Nexte-Inkrementale):

enum ids {
    OPEN, CLOSE;
    //
    private static final int BASE_ORDINAL = 100;
    public int getCode() {
        return ordinal() + BASE_ORDINAL;
    }
};

public class TestEnum {
    public static void main (String... args){
        for (ids i : new ids[] { ids.OPEN, ids.CLOSE }) {
            System.out.println(i.toString() + " " + 
                i.ordinal() + " " + 
                i.getCode());
        }
    }
}

OPEN 0 100
CLOSE 1 101

Die Funktion ordinal () gibt die relative Position des Bezeichners in der Aufzählung zurück. Sie können dies verwenden, um eine automatische Indizierung mit einem Versatz zu erhalten, wie bei einer Aufzählung im C-Stil.

Beispiel:

public class TestEnum {
    enum ids {
        OPEN,
        CLOSE,
        OTHER;

        public final int value = 100 + ordinal();
    };

    public static void main(String arg[]) {
        System.out.println("OPEN:  " + ids.OPEN.value);
        System.out.println("CLOSE: " + ids.CLOSE.value);
        System.out.println("OTHER: " + ids.OTHER.value);
    }
};

Gibt die Ausgabe:

OPEN:  100
CLOSE: 101
OTHER: 102

Bearbeiten: Ich habe gerade festgestellt, dass dies der Antwort von ggrandes sehr ähnlich ist , aber ich werde es hier belassen, weil es sehr sauber und ungefähr so ​​nah wie möglich an einer Aufzählung im C-Stil ist.

@scottf

Eine Aufzählung ist wie ein Singleton. Die JVM erstellt die Instanz.

Wenn Sie es selbst mit Klassen erstellen würden, könnte es so aussehen

public static class MyEnum {

    final public static MyEnum ONE;
    final public static MyEnum TWO;

    static {
        ONE = new MyEnum("1");
        TWO = new MyEnum("2");
    }

    final String enumValue;

    private MyEnum(String value){
        enumValue = value;    
    }

    @Override
    public String toString(){
        return enumValue;
    }


}

Und könnte so verwendet werden:

public class HelloWorld{

   public static class MyEnum {

       final public static MyEnum ONE;
       final public static MyEnum TWO;

       static {
          ONE = new MyEnum("1");
          TWO = new MyEnum("2");
       }

       final String enumValue;

       private MyEnum(String value){
           enumValue = value;    
       }

       @Override
       public String toString(){
           return enumValue;
       }


   }

    public static void main(String []args){

       System.out.println(MyEnum.ONE);
       System.out.println(MyEnum.TWO);

       System.out.println(MyEnum.ONE == MyEnum.ONE);

       System.out.println("Hello World");
    }
}

 public class MyClass {
    public static void main(String args[]) {
     Ids id1 = Ids.OPEN;
     System.out.println(id1.getValue());
    }
}

enum Ids {
    OPEN(100), CLOSE(200);

    private final int id;
    Ids(int id) { this.id = id; }
    public int getValue() { return id; }
}

@scottf, Sie haben wahrscheinlich wegen des in der ENUM definierten Konstruktors verwirrt.

Lassen Sie mich das erklären.

Wenn eine Klasse class loadergeladen wird enum, wird auch der enumKonstruktor aufgerufen. Auf was!! Ja, es ist aufgerufen OPENund close. Mit welchen Werten 100für OPENund 200fürclose

Kann ich einen anderen Wert haben?

Ja,

public class MyClass {
    public static void main(String args[]) {
     Ids id1 = Ids.OPEN;
     id1.setValue(2);
     System.out.println(id1.getValue());
    }
}

enum Ids {
    OPEN(100), CLOSE(200);

    private int id;
    Ids(int id) { this.id = id; }
    public int getValue() { return id; }
    public void setValue(int value) { id = value; }
}

Aber es ist eine schlechte Praxis. enumwird zur Darstellung von constantslike verwendet days of week, colors in rainbowdh einer solchen kleinen Gruppe vordefinierter Konstanten.

Ich denke, Sie sind verwirrt, wenn Sie sich C ++ - Enumeratoren ansehen. Java-Enumeratoren sind unterschiedlich.

Dies wäre der Code, wenn Sie an C / C ++ - Aufzählungen gewöhnt sind:

public class TestEnum {
enum ids {
    OPEN,
    CLOSE,
    OTHER;

    public final int value = 100 + ordinal();
};

public static void main(String arg[]) {
    System.out.println("OPEN:  " + ids.OPEN.value);
    System.out.println("CLOSE: " + ids.CLOSE.value);
    System.out.println("OTHER: " + ids.OTHER.value);
}
};