In welke gevallen kan de modifier final in Java…

De final modifier in Java kan worden toegepast op:

Variabelen:
- Lokale variabelen: Hun waarde wordt één keer toegekend en kan na initialisatie niet worden gewijzigd.
- Klasselvelden: De waarde van het veld wordt toegekend bij declaratie of in de constructor en kan daarna niet worden gewijzigd.
- Methodparameters: Een parameter binnen een methode wordt een constante; deze kan niet opnieuw worden toegewezen binnen de methode.
Het gebruik van final op variabelen garandeert:
- Immutabiliteit: Garantie dat de waarde niet zal veranderen.
- Threadveiligheid: final velden van een klasse zijn automatisch zichtbaar voor alle threads na voltooiing van de constructor zonder extra synchronisatie.
- Compileroptimalisaties: De compiler kan bepaalde optimalisaties uitvoeren omdat de waarde niet zal veranderen.
Methoden:
- Een methode die als final is gedeclareerd, kan niet worden overschreven in subklassen.
- Dit is nuttig voor:
  - Voorkomen van ongewenste gedragswijzigingen: Garandeert dat de logica van de methode ongewijzigd blijft.
  - Stimuleren van compositie: Dwingt tot gebruik van compositie in plaats van overerving.
  - Mogelijke compileroptimalisaties: De compiler kan inline-uitbreidingen van final methoden uitvoeren.
Klassen:
- Een klasse die als final is gedeclareerd, kan geen subklassen hebben.
- Het gebruik van final op een klasse wordt toegepast voor:
  - Het creëren van onveranderlijke (immutabele) klassen: Bijvoorbeeld wrapper-klassen voor primitieve types (Integer, String).
  - Bescherming van het ontwerp: Voorkomt uitbreiding die de invarianten van de klasse kan schenden.
  - Verhoogde veiligheid: Garandeert dat het gedrag van de klasse niet kan worden gewijzigd door subklassen.

Toepassing	Beschrijving	Voordelen
`final` veld	Waarde wordt één keer toegekend (bij declaratie of in de constructor).	Immutabiliteit, threadveiligheid, optimalisaties.
`final` parameter	Waarde kan niet worden gewijzigd binnen de methode.	Duidelijke signatuur, garantie van onveranderlijkheid van de parameterwaarde.
`final` methode	Kan niet worden overschreven in subklassen.	Voorkomt gedragswijzigingen, stimuleert compositie, optimalisaties.
`final` klasse	Kan geen subklassen hebben (niet-erfelijkheid mogelijk).	Immutabiliteit van de klasse, bescherming van het ontwerp, verhoogde veiligheid.

Voorbeelden:

public class Example {
    // final veld van de klasse
    private final String name;

    // final primitief veld
    private final int id;

    // final, maar kan verwijzen naar verschillende objecten van List zolang deze niet is gemaakt
    // na creatie kan de lijst worden gewijzigd, maar de referentie niet worden hergebruikt
    private final List<String> items;

    // Compileertijd constante
    public static final double PI = 3.14159;

    public Example(String name, int id) {
        this.name = name; // toewijzing aan final veld
        this.id = id;     // toewijzing aan final veld
        this.items = new ArrayList<>(); // initialisatie van final lijst
    }

    // final methode
    public final void printDetails() {
        System.out.println("Name: " + name + ", ID: " + id);
    }

    // Methode met final parameter
    public void addItem(final String item) {
        // item = "nieuw element"; // compileerfout: Cannot assign a value to final variable 'item'
        items.add(item);
    }
}

// final klasse
// public final class ImmutableClass {
//     private final int value;
//
//     public ImmutableClass(int value) {
//         this.value = value;
//     }
//
//     public int getValue() {
//         return value;
//     }
// }

// public class SubclassOfImmutable extends ImmutableClass { // compileerfout: Cannot inherit from final class
// }

In welke gevallen kan de modifier final in Java worden toegepast?