Enumerații (enum)

Pe lângă tipurile primitive și clase, în Java există un tip numit enum sau enumerare. Enumerațiile reprezintă un set de constante logic legate între ele. Enumerația este declarată cu ajutorul cuvântului cheie enum, urmat de numele enumerației. Apoi, este prezentată lista elementelor enumerației, separate prin virgulă:

enum Day {
   MONDAY,
   TUESDAY,
   WEDNESDAY,
   THURSDAY,
   FRIDAY,
   SATURDAY,
   SUNDAY
}

Enumerațiile reprezintă de fapt un nou tip de date, astfel încât putem defini o variabilă de acest tip și o putem utiliza:

public class Program {
   public static void main(String[] args) {
       Day current = Day.MONDAY;
       System.out.println(current);  // MONDAY
   }
}

enum Day {
   MONDAY,
   TUESDAY,
   WEDNESDAY,
   THURSDAY,
   FRIDAY,
   SATURDAY,
   SUNDAY
}

Enumerațiile pot fi utilizate în clase pentru a stoca date:

public class Program {
   public static void main(String[] args) {
       Book b1 = new Book("War and Peace", "L. Tolstoy", Type.BELLETRE);
       System.out.printf("Cartea '%s' are tipul %s \n", b1.name, b1.getType());
   }
}

class Book {
   private Type bookType;
   String name;
   String author;

   Book(String name, String author, Type type) {
       this.bookType = type;
       this.name = name;
       this.author = author;
   }

   String getType() {
       switch(bookType) {
           case BELLETRE: return "Belletre";
           case SCIENCE: return "Science";
           case SCIENCE_FICTION: return "Science fiction";
           case PHANTASY: return "Phantasy";
           default: return "Undefined";
       }
   }
}

enum Type {
   SCIENCE,
   BELLETRE,
   PHANTASY,
   SCIENCE_FICTION
}

Enumerația este definită în afara clasei și conține patru genuri de cărți. Clasa Book include o variabilă de tipul enumerației noastre, care este inițializată în constructor la fel ca celelalte câmpuri ale clasei. Prin instrucțiunea switch..case, putem verifica ce tip de carte este stocat în bookType.

Rezultatul programului:

Cartea 'War and Peace' are tipul Belletre

Metode ale enumerațiilor

Fiecare enumerație are o metodă statică values(), care returnează un array cu toate constantele enumerației:

public class Program {
   public static void main(String[] args) {
       Type[] types = Type.values();
       for (Type s : types) { System.out.println(s); }
   }
}

enum Type {
   SCIENCE,
   BELLETRE,
   PHANTASY,
   SCIENCE_FICTION
}

Metoda ordinal() returnează indexul unei constante (indexarea începe de la 0):

System.out.println(Type.BELLETRE.ordinal());  // 1

Constructori, câmpuri și metode ale enumerațiilor

Enumerațiile, la fel ca și clasele obișnuite, pot defini constructori, câmpuri și metode. De exemplu:

public class Program {
   public static void main(String[] args) {
       System.out.println(Color.RED.getCode());    // #FF0000
       System.out.println(Color.GREEN.getCode());  // #00FF00
   }
}

enum Color {
   RED("#FF0000"), BLUE("#0000FF"), GREEN("#00FF00");
   
   private String code;
   
   Color(String code) {
       this.code = code;
   }
   
   public String getCode() {
       return code;
   }
}

Enumerația Color definește un câmp privat code pentru stocarea codului culorii, iar cu ajutorul metodei getCode() este returnat codul. Valoarea este transmisă prin constructor. Este important de menționat că, implicit, constructorul este privat. Prin urmare, nu putem crea constant enumerații din afara enumerației.

Definirea metodelor pentru constante individuale

De asemenea, putem defini metode pentru constantele individuale ale unei enumerații:

public class Program {
   public static void main(String[] args) {
       Operation op = Operation.SUM;
       System.out.println(op.action(10, 4));  // 14
       op = Operation.MULTIPLY;
       System.out.println(op.action(6, 4));   // 24
   }
}

enum Operation {
   SUM {
       public int action(int x, int y) { return x + y; }
   },
   SUBTRACT {
       public int action(int x, int y) { return x - y; }
   },
   MULTIPLY {
       public int action(int x, int y) { return x * y; }
   };

   public abstract int action(int x, int y);
}

Aici, fiecare constantă din enumerația Operation implementează metoda abstractă action() într-un mod diferit, în funcție de operația pe care o reprezintă.