În ce cazuri se poate aplica modificatorul final în Java?

Modifierul final în Java poate fi aplicat la:

1. Variabile:

   • Variabile locale: Valoarea lor este atribuită o singură dată și nu poate fi schimbată după inițializare.
   • Câmpuri ale clasei: Valoarea câmpului este atribuită fie la declarare, fie în constructor și apoi nu poate fi schimbată.
   • Parametri ai metodei: Un parametru din interiorul unei metode devine constant; nu poate fi reasignat în interiorul corpului metodei.

   Utilizarea final pentru variabile asigură:

   • Imutabilitate: Garanția că valoarea nu se va schimba.
   • Siguranța thread-urilor: Câmpurile final ale clasei sunt vizibile automat tuturor thread-urilor după finalizarea constructorului fără sincronizare suplimentară.
   • Optimizări ale compilatorului: Compilatorul poate realiza anumite optimizări știind că valoarea nu se va schimba.

2. Metode:

   • O metodă declarată ca final nu poate fi suprascrisă în subclase.
   • Acest lucru este util pentru:
     • Prevenirea modificărilor nedorite ale comportamentului: Garantează că logica metodei rămâne neschimbată.
     • Stimularea compoziției: Încurajează utilizarea compoziției în loc de moștenire.
     • Optimizări posibile ale compilatorului: Compilatorul poate realiza inline pentru metodele final.

3. Clase:

   • O clasă declarată ca final nu poate avea subclase.
   • Aplicarea final la clasă este folosită pentru:
     • Crearea de clase imutabile: De exemplu, clase wrapper pentru tipurile primitive (Integer, String).
     • Protejarea designului: Previne extinderea care poate încălca invariabilele clasei.
     • Creșterea securității: Garantează că comportamentul clasei nu poate fi modificat prin crearea de subclase.

Aplicare	Descriere	Avantaje
final câmp	Valoarea este atribuită o singură dată (la declarare sau în constructor).	Imutabilitate, siguranța thread-urilor, optimizări.
final parametru	Valoarea nu poate fi modificată în interiorul metodei.	Semnătură clară, garanția imutabilității valorii parametrului.
final metodă	Nu poate fi suprascrisă în subclase.	Prevenirea modificării comportamentului, stimularea compoziției, optimizări.
final clasă	Nu poate avea subclase (nu se poate moșteni).	Imutabilitatea clasei, protecția designului, creșterea securității.

Exemple:

public class Example {
    // câmp final al clasei
    private final String name;

    // câmp final primitiv
    private final int id;

    // câmp final, dar poate fi referință la diferite obiecte List atâta timp cât nu este creat
    // după crearea obiectului, lista poate fi modificată, dar referința nu
    private final List<String> items;

    // Constantă de timp de compilare
    public static final double PI = 3.14159;

    public Example(String name, int id) {
        this.name = name; // atribuirea câmpului final
        this.id = id;     // atribuirea câmpului final
        this.items = new ArrayList<>(); // inițializarea câmpului final de listă
    }

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

    // metodă cu parametru final
    public void addItem(final String item) {
        // item = "element nou"; // eroare de compilare: Cannot assign a value to final variable 'item'
        items.add(item);
    }
}

// clasă 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 { // Eroare de compilare: Cannot inherit from final class
// }