Puis-je définir la valeur de départ enum en Java?

J'utilise l'énumération pour faire quelques constantes:

enum ids {OPEN, CLOSE};

la valeur OPEN est zéro, mais je veux que ce soit 100. Est-ce possible?

Les énumérations Java ne sont pas comme les énumérations C ou C ++, qui ne sont en réalité que des étiquettes d'entiers.

Les énumérations Java sont implémentées plus comme des classes - et elles peuvent même avoir plusieurs attributs.

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

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

La grande différence est qu'ils sont de type sûr ce qui signifie que vous n'avez pas à vous soucier de l'attribution d'une énumération COLOR à une variable SIZE.

Voir http://docs.oracle.com/javase/tutorial/java/javaOO/enum.html pour en savoir plus.

Oui. Vous pouvez passer les valeurs numériques au constructeur de l'énumération, comme ceci:

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

  private int value;    

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

  public int getValue() {
    return value;
  }
}

Reportez-vous au Guide du langage Sun Java pour plus d'informations.

ce qu'il faut utiliser de cette façon:

public enum HL_COLORS{
          YELLOW,
          ORANGE;

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

il n'y a qu'une seule méthode ..

vous pouvez utiliser une méthode statique et passer l'Enum en tant que paramètre comme:

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

Notez que ces deux façons utilisent moins de mémoire et plus d'unités de processus. Je ne dis pas que c'est la meilleure façon mais c'est juste une autre approche.

Si vous utilisez des types d'énumération très volumineux, les éléments suivants peuvent être utiles;

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 vous souhaitez émuler l'énumération de C / C ++ (nombre de base et incréments suivants):

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 fonction ordinal () renvoie la position relative de l'identifiant dans l'énumération. Vous pouvez l'utiliser pour obtenir une indexation automatique avec un décalage, comme avec une énumération de style C.

Exemple:

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

Donne la sortie:

OPEN:  100
CLOSE: 101
OTHER: 102

Edit: je viens de réaliser que cela est très similaire à la réponse de ggrandes , mais je vais le laisser ici car il est très propre et à peu près aussi proche que possible d'une énumération de style C.

@scottf

Une énumération est comme un singleton. La JVM crée l'instance.

Si vous le créiez vous-même avec des classes, cela pourrait ressembler à ça

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


}

Et pourrait être utilisé comme ça:

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, vous avez probablement confondu à cause du constructeur défini dans l'ENUM.

Permettez-moi d'expliquer cela.

Lors du class loaderchargement de la enumclasse, le enumconstructeur est également appelé. Sur quoi!! Oui, c'est appelé OPENet close. Avec quelles valeurs 100pour OPENet 200pourclose

Puis-je avoir une valeur différente?

Oui,

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

Mais c'est une mauvaise pratique. enumest utilisé pour représenter constantscomme days of week, colors in rainbowc'est -à- dire un petit groupe de constantes prédéfinies.

Je pense que vous êtes confus de regarder les énumérateurs C ++. Les énumérateurs Java sont différents.

Ce serait le code si vous êtes habitué aux énumérations 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);
}
};