¿Puedo establecer el valor de inicio de enumeración en Java?

Utilizo la enumeración para hacer algunas constantes:

enum ids {OPEN, CLOSE};

el valor ABIERTO es cero, pero lo quiero como 100. ¿Es posible?

Las enumeraciones de Java no son como las enumeraciones de C o C ++, que en realidad son solo etiquetas para enteros.

Las enumeraciones Java se implementan más como clases, e incluso pueden tener múltiples atributos.

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

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

La gran diferencia es que son de tipo seguro, lo que significa que no tiene que preocuparse por asignar una enumeración COLOR a una variable SIZE.

Consulte http://docs.oracle.com/javase/tutorial/java/javaOO/enum.html para obtener más información.

Si. Puede pasar los valores numéricos al constructor para la enumeración, así:

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

  private int value;    

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

  public int getValue() {
    return value;
  }
}

Consulte la Guía del lenguaje Sun Java para obtener más información.

¿Qué hay de usar de esta manera:

public enum HL_COLORS{
          YELLOW,
          ORANGE;

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

solo hay un método ...

puede usar el método estático y pasar la enumeración como parámetro como:

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

Tenga en cuenta que estas dos formas usan menos memoria y más unidades de proceso. No digo que esta sea la mejor manera, pero es solo otro enfoque.

Si usa tipos de enumeración muy grandes, los siguientes pueden ser útiles;

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

Si desea emular una enumeración de C / C ++ (números base y nexts incrementales):

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 función ordinal () devuelve la posición relativa del identificador en la enumeración. Puede usar esto para obtener una indexación automática con un desplazamiento, como con una enumeración de estilo C.

Ejemplo:

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

Da la salida:

OPEN:  100
CLOSE: 101
OTHER: 102

Editar: acabo de darme cuenta de que esto es muy similar a la respuesta de ggrandes , pero lo dejaré aquí porque está muy limpio y lo más cerca posible de una enumeración de estilo C.

@scottf

Una enumeración es como un Singleton. La JVM crea la instancia.

Si lo crearas tú mismo con clases, podría verse así

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


}

Y podría usarse así:

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, probablemente confundiste debido al constructor definido en ENUM.

Déjame explicarte eso.

Cuando class loadercarga la enumclase, el enumconstructor también llama. ¡¡En que!! Sí, se llama OPENy close. Con qué valores 100para OPENy 200paraclose

¿Puedo tener un valor diferente?

Si,

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

Pero, es una mala práctica. enumse usa para representar constantslike days of week, colors in rainbowes decir, un pequeño grupo de constantes predefinidas.

Creo que estás confundido al mirar los enumeradores de C ++. Los enumeradores de Java son diferentes.

Este sería el código si está acostumbrado a enumeraciones de 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);
}
};