Posso impostare il valore iniziale enum in Java?

Uso l'enum per creare alcune costanti:

enum ids {OPEN, CLOSE};

il valore APERTO è zero, ma lo voglio come 100. È possibile?

Gli enum Java non sono come gli enum C o C ++, che sono in realtà solo etichette per numeri interi.

Gli enum Java sono implementati più come le classi e possono anche avere più attributi.

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

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

La grande differenza è che sono sicuri per il tipo che significa che non devi preoccuparti di assegnare un enum COLOR a una variabile SIZE.

Vedi http://docs.oracle.com/javase/tutorial/java/javaOO/enum.html per ulteriori informazioni.

Sì. È possibile passare i valori numerici al costruttore per l'enum, in questo modo:

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

  private int value;    

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

  public int getValue() {
    return value;
  }
}

Consultare la Guida linguistica di Sun Java per ulteriori informazioni.

che ne dici di usare in questo modo:

public enum HL_COLORS{
          YELLOW,
          ORANGE;

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

c'è solo un metodo ..

puoi usare il metodo statico e passare l'Enum come parametro come:

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

Si noti che questi due modi utilizzano meno memoria e più unità di processo. Non dico che questo è il modo migliore ma è solo un altro approccio.

Se si usano tipi di enum molto grandi, seguire può essere utile;

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

Se vuoi emulare enum di C / C ++ (base num e nexts incrementals):

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

La funzione ordinal () restituisce la posizione relativa dell'identificatore nell'enum. Puoi usarlo per ottenere l'indicizzazione automatica con un offset, come con un enum di tipo C.

Esempio:

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

Fornisce l'output:

OPEN:  100
CLOSE: 101
OTHER: 102

Modifica: ho appena realizzato che questo è molto simile alla risposta di Ggrandes , ma lo lascerò qui perché è molto pulito e il più vicino possibile a un enum in stile C.

@scottf

Un enum è come un Singleton. La JVM crea l'istanza.

Se lo creassi da solo con le classi, potrebbe essere così

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


}

E potrebbe essere usato così:

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, probabilmente sei confuso a causa del costruttore definito in ENUM.

Lascia che te lo spieghi.

Quando class loadercarica enumclasse, enumviene chiamato anche dal costruttore. Su cosa!! Sì, si chiama OPENe close. Con quali valori 100per OPENe 200perclose

Posso avere un valore diverso?

Sì,

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

Ma è una cattiva pratica. enumè usato per rappresentare constantssimili days of week, colors in rainbowcioè un piccolo gruppo di costanti predefinite.

Penso che tu sia confuso guardando gli enumeratori C ++. Gli enumeratori Java sono diversi.

Questo sarebbe il codice se sei abituato alle enumerazioni C / C ++:

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