Wejścia do automatycznego zwiększania Java?

Question

Czy Java zezwala na coś w rodzaju dobrego ol C, czy nawet C# w tym sensie, że można zdefiniować wyliczenie z polami, które automatycznie rosną w wartości i zaczynają od opcjonalnie podanej wartości?

E.g.

w C lub C#:

enum Foo { A = 10, B, C, D = 5000, E, Fish }; 

plony A = 10, B = 11, C = 12, D = 5000 E = 5001, Ryba = 5002.

Answer 1

W Javie można” t podać wartości porządkowe jawnie w ogóle. Oni zawsze autoinkrementacji, od 0, bez kontroli nad nim.

Jeśli chcesz uzyskać inne wartości niestandardowe, musisz umieścić je w wywołaniach konstruktora i przechowywać je samodzielnie. Ci może dostać AUTOINCREMENT, ale icky jak cholery:

import java.util.EnumSet; 

// Please don't ever use this code. It's here so you can point and laugh. 
enum Foo 
{ 
    A(10), B, C, D(5000), E, Fish; 

    private static int nextValue; 
    private int value; 

    private Foo() 
    { 
     this(Counter.nextValue); 
    } 

    private Foo(int value) 
    { 
     this.value = value; 
     Counter.nextValue = value + 1; 
    } 

    public int getValue() 
    { 
     return value; 
    } 

    private static class Counter 
    { 
     private static int nextValue = 0; 
    } 
} 

public class Test 
{ 
    public static void main(String[] args) 
    { 
     for (Foo foo : EnumSet.allOf(Foo.class)) 
     { 
      System.out.println(foo.name() + " " + 
           foo.ordinal() + " " + 
           foo.getValue()); 
     } 
    } 
} 

Uwaga potrzeba zagnieżdżonej klasy, ponieważ nie można uzyskać dostęp do pól statycznych wewnątrz konstruktora enum. Ick, ick, ick. Proszę tego nie robić.

Answer 2

Jest to wybór projektu Java Enums, aby nie obsługiwać zmiany wartości porządkowych. Zasadniczo są one niezbyt stabilne wystarczy na nich polegać. Jeśli zmienisz pozycję B i C w przykładowych klientach, w zależności od wartości porządkowych są zepsute. Może się to zdarzyć nieumyślnie.

Problem opisano w Efektywna Java Item 31: Use instance field instead of ordinals.

można naśladować zachowanie w sposób stabilny:

enum X{ 
    A(10), B(A), C(B), D(5000), E(D), F(E); 

    private final int value; 

    X(int value){ 
     this.value = value; 
    } 

    X(X preceding){ 
     this.value = preceding.getValue() + 1; 
    } 

    public int getValue() { 
     return value; 
    } 

    @Override 
    public String toString() { 
     return this.name() + "(" + this.value + ")"; 
    } 

    static { 
     Set<Integer> values = new HashSet<Integer>(); 
     for(X x : X.values()) values.add(x.value); 
     assert(values.size() == X.values().length); //no duplicates 
    } 
} 

Z tej definicji można zmienić kolejność wartości bez zerwania klientów.

Wywoływanie for(X x : X.values()) System.out.println(x); powraca:

A(10) 
B(11) 
C(12) 
D(5000) 
E(5001) 
F(5002)