Hoe werken enums in Java?

Question

Accepted Answer

Een **enum** definieert een type met een **vaste set benoemde constanten**. Java enums zijn veel krachtiger dan eenvoudige constante lijsten in andere talen — het zijn volwaardige klassen die velden, constructors en methoden kunnen hebben.

## Basic enum

```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 bieden **type safety** — `Day today = Day.MONDAY` kan alleen geldige `Day` waarden bevatten, anders dan het gebruik van willekeurige ints of strings als constanten (die ongeldig waarden en typefouten toestaan).

## Built-in enum methoden

```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 met velden, constructors en methoden (het krachtige deel)

```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
```

Elke enum constante is een instantie, geconfigureerd via de constructor — waardoor je data en gedrag aan elke constante kunt koppelen. Dit is uniek en krachtig vergeleken met enums in de meeste andere talen.

## Enums kunnen interfaces implementeren en per-constant gedrag hebben

```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 zijn ideale singletons

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

## Waarom het belangrijk is

Java enums zijn een robuuste, type-veilige manier om vaste sets gerelateerde constanten (states, dagen, rollen, operaties) te representeren — veel beter dan het foutgevoelige alternatief van `int`/`String` constanten, die ongeldig waarden toestaan en geen type checking bieden.

Hun unieke kracht — velden, constructors, methoden, interface implementatie en per-constant gedrag — stelt je in staat om data en logica aan elke constante te koppelen, domeinconcepten elegant te modelleren (bijv. planeten met massa/zwaartekracht, operaties met hun wiskunde).

Ze bieden ook het veiligste singleton idioom.

Enums begrijpen buiten eenvoudige constante lijsten — als volwaardige klassen met staat en gedrag — maakt schoner, veiliger domeinmodellering mogelijk en is een veelvuldig ondergewaardeerde maar waardevolle Java functie, evenals een veelgesteld interviewonderwerp.