In quali casi si può applicare il modificatore final…

Il modificatore final in Java può essere applicato a:

Variabili:
- Variabili locali: Il loro valore viene assegnato una volta e non può essere modificato dopo l'inizializzazione.
- Campi di classe: Il valore del campo viene assegnato durante la dichiarazione o nel costruttore e poi non può essere modificato.
- Parametri di metodo: Il parametro all'interno del metodo diventa una costante; non può essere riassegnato all'interno del corpo del metodo.
Applicare final alle variabili garantisce:
- Immutabilità: Garanzia che il valore non cambierà.
- Sicurezza in multithreading: I campi final di una classe sono visibili a tutti i thread dopo che il costruttore termina senza sincronizzazione aggiuntiva.
- Ottimizzazioni del compilatore: Il compilatore può effettuare alcune ottimizzazioni sapendo che il valore non cambierà.
Metodi:
- Un metodo dichiarato come final non può essere sovrascritto nelle sottoclassi.
- Questo è utile per:
  - Prevenire cambiamenti indesiderati di comportamento: Garantisce che la logica del metodo rimanga invariata.
  - Favorire la composizione: Incoraggia l'uso della composizione invece dell'ereditarietà.
  - Possibili ottimizzazioni del compilatore: Il compilatore può eseguire l'inlining delle chiamate ai metodi final.
Classi:
- Una classe dichiarata come final non può avere sottoclassi.
- L'uso di final su una classe viene utilizzato per:
  - Creare classi immutabili (immutable): Ad esempio, le classi wrapper dei tipi primitivi (Integer, String).
  - Proteggere il design: Impedisce l'estensione che potrebbe violare gli invarianti della classe.
  - Aumentare la sicurezza: Garantisce che il comportamento della classe non possa essere modificato tramite sottoclassi.

Applicazione	Descrizione	Vantaggi
`final` campo	Il valore viene assegnato una volta (alla dichiarazione o nel costruttore).	Immutabilità, sicurezza in multithreading, ottimizzazioni.
`final` parametro	Il valore non può essere modificato all'interno del metodo.	Firma chiara, garanzia di immutabilità del valore del parametro.
`final` metodo	Non può essere sovrascritto nelle sottoclassi.	Prevenzione di cambiamenti di comportamento, promozione della composizione, ottimizzazioni.
`final` classe	Non può avere sottoclassi (impossibile l'ereditarietà).	Immutabilità della classe, protezione del design, aumento della sicurezza.

Esempi:

public class Example {
    // campo final di classe
    private final String name;

    // campo primitivo final
    private final int id;

    // campo final, ma può essere riferimento a diversi oggetti List finché non viene creato
    // dopo la creazione, si può cambiare la referenza, ma non la referenza stessa
    private final List<String> items;

    // Costante di tempo di compilazione
    public static final double PI = 3.14159;

    public Example(String name, int id) {
        this.name = name; // assegnazione al campo final
        this.id = id;     // assegnazione al campo final
        this.items = new ArrayList<>(); // inizializzazione del campo final
    }

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

    // metodo con parametro final
    public void addItem(final String item) {
        // item = "nuovo elemento"; // errore di compilazione: impossibile assegnare a una variabile final
        items.add(item);
    }
}

// classe final
// 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 { // errore di compilazione: impossibile ereditare da una classe final
// }
```}}}}}```

In quali casi si può applicare il modificatore final in Java?