Posso definir o valor inicial de enum em Java?

Eu uso o enum para fazer algumas constantes:

enum ids {OPEN, CLOSE};

o valor OPEN é zero, mas eu quero como 100. É possível?

As enumerações Java não são como as enumerações C ou C ++, que são apenas rótulos para números inteiros.

As enums de Java são implementadas mais como classes - e podem até ter vários atributos.

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

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

A grande diferença é que eles são seguros para o tipo, o que significa que você não precisa se preocupar em atribuir uma enumeração COLOR a uma variável SIZE.

Veja http://docs.oracle.com/javase/tutorial/java/javaOO/enum.html para obter mais informações.

Sim. Você pode passar os valores numéricos para o construtor da enumeração, da seguinte maneira:

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

  private int value;    

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

  public int getValue() {
    return value;
  }
}

Consulte o Sun Java Language Guide para obter mais informações.

que tal usar desta maneira:

public enum HL_COLORS{
          YELLOW,
          ORANGE;

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

existe apenas um método ..

você pode usar o método estático e passar o Enum 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;
            }
          }

Observe que essas duas maneiras usam menos memória e mais unidades de processo. Não digo que essa seja a melhor maneira, mas é apenas outra abordagem.

Se você usar tipos de enumeração muito grandes, poderá ser útil seguir;

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 você deseja emular a enumeração de C / C ++ (número base e nexos incrementais):

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

A função ordinal () retorna a posição relativa do identificador na enumeração. Você pode usar isso para obter a indexação automática com um deslocamento, como em uma enumeração no estilo C.

Exemplo:

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

Dá a saída:

OPEN:  100
CLOSE: 101
OTHER: 102

Edit: acabei de perceber que isso é muito semelhante à resposta de ggrandes , mas vou deixar aqui porque é muito limpo e o mais próximo possível de uma enumeração de estilo C.

@scottf

Um enum é como um Singleton. A JVM cria a instância.

Se você o criar sozinho com classes, pode ser assim

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 poderia ser usado assim:

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, você provavelmente confundiu por causa do construtor definido no ENUM.

Deixe-me explicar isso.

Quando class loadercarrega a enumclasse, o enumconstrutor também é chamado. Em que!! Sim, é chamado OPENe close. Com que valores 100para OPENe 200paraclose

Posso ter um valor diferente?

Sim,

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

Mas, é uma prática ruim. enumé usado para representar constantsiguais days of week, colors in rainbowou seja, um pequeno grupo de constantes predefinidas.

Eu acho que você está confuso de olhar para enumeradores C ++. Os enumeradores Java são diferentes.

Esse seria o código se você estiver acostumado a enumerações 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);
}
};