Cum funcționează enums în Java?

Question

Accepted Answer

Un **enum** definește un tip cu un **set fix de constante numite**. Enums-urile din Java sunt mult mai puternice decât listele simple de constante din alte limbaje — sunt clase complete care pot avea câmpuri, constructori și metode.

## Enum de bază

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

Day today = Day.MONDAY;

// works great in switch
switch (today) {
    case MONDAY -> System.out.println("start of week");
    case SATURDAY, SUNDAY -> System.out.println("weekend");
    default -> System.out.println("weekday");
}
```

Enums-urile oferă **type safety** — `Day today = Day.MONDAY` poate conține doar valori `Day` valide, spre deosebire de utilizarea unor numere întregi arbitrare sau stringuri ca constante (care permit valori nevalide și greșeli de tipar).

## Metode de enum încorporate

```java
Day.MONDAY.name();        // "MONDAY"
Day.MONDAY.ordinal();     // 0 — position in the declaration
Day.values();             // array of all constants (iterate them)
Day.valueOf("FRIDAY");    // get a constant by name
for (Day d : Day.values()) { ... }   // iterate all values
```

## Enums cu câmpuri, constructori și metode (partea puternică)

```java
public enum Planet {
    MERCURY(3.3e23, 2.4e6),    // each constant calls the constructor with arguments
    EARTH(5.97e24, 6.37e6),
    JUPITER(1.9e27, 7.1e7);

private final double mass;       // enums can have FIELDS
    private final double radius;

Planet(double mass, double radius) {   // constructor (implicitly private)
        this.mass = mass;
        this.radius = radius;
    }
    public double surfaceGravity() {        // and METHODS
        return 6.67e-11 * mass / (radius * radius);
    }
}

Planet.EARTH.surfaceGravity();   // compute using EARTH's data
```

Fiecare constantă enum este o instanță, configurată prin constructor — permițând asocierea datelor și comportamentului cu fiecare constantă. Aceasta este unică și puternică comparativ cu enums-urile din majoritatea limbajelor.

## Enums-urile pot implementa interfețe și au comportament per-constantă

```java
public enum Operation {
    PLUS { public int apply(int a, int b) { return a + b; } },
    TIMES { public int apply(int a, int b) { return a * b; } };
    public abstract int apply(int a, int b);   // each constant implements it differently
}
Operation.PLUS.apply(2, 3);   // 5
```

## Enums-urile sunt singletons ideali

```java
public enum Config { INSTANCE; /* fields/methods */ }
// enum singletons are thread-safe and serialization-safe by design
```

## De ce este important

Enums-urile din Java sunt o modalitate robustă și type-safe de a reprezenta seturi fixe de constante conexe (stări, zile, roluri, operații) — mult superioare alternativei predispuse la erori a constantelor `int`/`String`, care permit valori nevalide și nu oferă nicio verificare de tip.

Puterea lor unică — câmpuri, constructori, metode, implementare de interfețe și comportament per-constantă — vă permite să atașați date și logică fiecărei constante, modelând concepte de domeniu elegant (de exemplu, planete cu masă/gravitație, operații cu matematica lor).

Ele oferă de asemenea idiomul cel mai sigur pentru singletons.

Înțelegerea enums-urilor dincolo de listele simple de constante — ca clase complete cu stare și comportament — permite modelarea domeniului mai curată și mai sigură și este o caracteristică din Java adesea subutilizată dar valoroasă, precum și un subiect frecvent în interviuri.