Inferenza dei tipi, costanti in Java

1. Parola chiave var

Quando iniziamo a scrivere codice in Java, incontriamo un sistema di tipi rigoroso: ogni variabile deve essere dichiarata esplicitamente — occorre indicarne il tipo. Questo è utile per l’affidabilità, ma a volte le dichiarazioni diventano ingombranti e appesantiscono il codice. Per semplificare la vita, in Java è stato aggiunto uno strumento comodo — l’inferenza del tipo (var).

var permette di scrivere codice più corto e pulito senza sacrificare la sicurezza dei tipi: scrivi il valore e il compilatore deduce automaticamente il tipo.

Esempio

var age = 23;            // il compilatore dedurrà il tipo del numero 23 e sostituirà con int age
var name = "Anna";       // il compilatore dedurrà il tipo di "Anna" e sostituirà con String name
var price = 99.99;       // il compilatore dedurrà il tipo del valore 99.99 e sostituirà con double price

Perché è stato introdotto var?

• Leggibilità: non serve scrivere manualmente tipi lunghi (come HashMap<String, List<Integer>>).
• Flessibilità: consente di cambiare più facilmente i tipi in futuro: modifichi a destra — a sinistra var si adatta da solo.
• Stile moderno: quasi tutti i progetti Java moderni usano var quando il tipo è facilmente leggibile dall’inizializzazione.

Quando si può (e si deve) usare var

• Quando dalla parte destra è evidente il tipo della variabile.
• Quando il tipo è ovvio (var price = 100; — è chiaro che è un int).
• Quando il tipo è troppo lungo o complesso (per esempio, HashMap<Integer, List<Calendar>>).

Esempio con array

var numbers = new int[] { 1, 2, 3, 4 };

Esempio con metodo

var input = console.nextLine(); // input è una String (il metodo restituisce String)

Quando è meglio NON usare var

Se il tipo non è ovvio dalla parte destra, il codice può diventare meno comprensibile. Se tra un mese non capirai tu stesso che tipo sia, è meglio indicarlo esplicitamente.

var mystery = DoSomethingVeryComplicated(); // CHI SEI, mystery???

Qui è meglio indicare esplicitamente il tipo:

String result = DoSomethingVeryComplicated();

Regola d’oro: usa var solo dove non peggiora la leggibilità!

var — solo per variabili locali

La parola chiave var funziona solo per variabili locali — all’interno dei metodi. Non si può usare var per:

• parametri del metodo;
• campi della classe;
• costanti.

Come funziona var “sotto il cofano”

• Il compilatore Java, in fase di compilazione, sostituisce il tipo corretto.
• Dopo la compilazione non resta alcun var.
• Nessuna perdita di prestazioni: è solo una comodità per il programmatore.

var year = 2025; // in fase di compilazione diventa: int year = 2025;

Errori tipici nell’uso di var

Variabile non inizializzata:

var a; // ERRORE: il compilatore non ha da cosa dedurre il tipo!

Inizializzazione ambigua:

var list = null; // ERRORE: il tipo non è deducibile da null!

Riutilizzo della variabile con tipi diversi:

var value = 5;     // value è int
value = "Cinque";  // ERRORE: value è già int!

Confronto: tipi espliciti e var

int age = 42;

var age = 42;

HashMap<Integer, String> dict = SomeFunc();

var dict = SomeFunc();

String[] names = ...

var names = ...

2. Parola chiave final: dichiarazione delle costanti

Una costante è una variabile il cui valore non può essere modificato dopo l’inizializzazione. Le costanti rendono il codice affidabile, chiaro e proteggono da modifiche accidentali di numeri e stringhe importanti.

• Numero pi (PI = 3.14159…)
• Numero massimo di utenti (MAX_USERS = 1000)
• Nome dell’azienda (COMPANY_NAME = "CodeGym")

In Java per dichiarare una costante si usa il modificatore final. Dice al compilatore: “dopo la prima assegnazione — non si può più cambiare!”

final Tipo NOME_COSTANTE = valore;

Sintassi

final int DAYS_IN_WEEK = 7;
final double PI = 3.1415926535;
final String GREETING = "Ciao, Java!";

Punti importanti:

• Una variabile con final deve essere inizializzata (subito o nel costruttore — se è un campo della classe).
• Un tentativo di modificarne il valore provocherà un errore di compilazione.

Esempio: non si può modificare una variabile final

final int MAX_USERS = 100;
MAX_USERS = 200; // Errore: non è possibile assegnare un nuovo valore a una variabile final

Commento: se decommenti l’assegnazione — il progetto non verrà compilato.

3. static final: costanti a livello di classe

In Java spesso servono costanti che non dipendono da un oggetto specifico — “comuni” a tutta la classe. Per questo si usa la combinazione static + final.

Perché static final?

• static — la variabile appartiene alla classe (una sola per tutti).
• final — il valore non può essere modificato.

Sintassi

public static final double PI = 3.1415926535;
public static final int MAX_USERS = 1000;
public static final String COMPANY_NAME = "CodeGym";

Dove dichiararle? Di solito — all’inizio della classe (prima dei metodi).

Esempio di utilizzo nella classe

public class MathUtils 
{
    public static final double PI = 3.1415926535;

    public static double circleLength(double radius) 
    {
        return 2 * PI * radius;
    }
}

Chiamata:

double len = MathUtils.circleLength(5);
System.out.println(len); // 31.4159...

Nota bene: si accede alla costante tramite il nome della classe: MathUtils.PI.

4. Differenza tra semplice final e static final

final — il valore del campo non può essere modificato dopo l’inizializzazione, ma ogni oggetto ha il proprio valore.

static final — un’unica costante per l’intera classe, non dipende dagli oggetti.

Esempio: differenza nella pratica

public class User 
{
    public final String name;                       // Ogni User ha il proprio nome (final)
    public static final String COMPANY = "CodeGym"; // Un'unica azienda per tutti (static final)

    public User(String name) 
    {
        this.name = name;
    }
}

User u1 = new User("Vasya");
User u2 = new User("Petya");

System.out.println(u1.name);      // Vasya
System.out.println(u2.name);      // Petya
System.out.println(User.COMPANY); // CodeGym

Conclusione: name — campo individuale immutabile, COMPANY — costante comune.

Convenzioni di denominazione delle costanti

È consuetudine nominare le costanti in MAIUSCOLO_SEPARATE_DA_UNDERSCORE.

public static final int MAX_USERS = 1000;
public static final double GRAVITY = 9.81;
public static final String DEFAULT_GREETING = "Hello, world!";

Consiglio: se vedi un nome del genere — non provare a cambiarne il valore nel codice: il compilatore non lo permetterà.

5. Pratica: dichiarazione e utilizzo delle costanti

Esempio: classe con costanti

public class CircleCalculator 
{
    public static final double PI = 3.1415926535;

    public static double getLength(double radius) 
    {
        return 2 * PI * radius;
    }

    public static double getArea(double radius) 
    {
        return PI * radius * radius;
    }
}

Utilizzo:

public class Main 
{
    public static void main(String[] args) 
    {
        double r = 5.0;
        System.out.println("Lunghezza della circonferenza: " + CircleCalculator.getLength(r));
        System.out.println("Area del cerchio: " + CircleCalculator.getArea(r));
    }
}

Risultato:

Lunghezza della circonferenza: 31.415926535
Area del cerchio: 78.5398163375

Tentativo di modificare la costante

CircleCalculator.PI = 3.14; // Errore di compilazione: cannot assign a value to final variable PI

6. Particolarità e sfumature

Costanti per oggetti

È possibile dichiarare final per i riferimenti a oggetti, ma questo non rende l’oggetto immutabile! Impedisce solo di assegnare alla variabile un altro riferimento.

final StringBuilder sb = new StringBuilder("Hello");
sb = new StringBuilder("World"); // Errore: non è possibile assegnare un nuovo oggetto
sb.append(", Java!");            // Consentito — cambia lo stato dell'oggetto
System.out.println(sb);          // Hello, Java!

Conclusione: final protegge il riferimento, non l’oggetto. Per una vera immutabilità usa classi immutabili (ad esempio, String, List.of(), ecc.).

Uso delle costanti al posto dei “numeri magici”

Stile scorretto:

double area = 3.1415 * r * r; // Che cos'è 3.1415? Perché proprio questo numero?

Stile corretto:

double area = PI * r * r; // È subito chiaro che si usa il valore di PI

7. Errori tipici nel lavoro con le costanti e var

Errore n. 1: tentativo di modificare il valore di una variabile final. Se una variabile è dichiarata con final, una nuova assegnazione provocherà un errore di compilazione.

Errore n. 2: tentativo di dichiarare una costante tramite var. Per le costanti usa sempre un tipo esplicito insieme a final o static final. var — solo per variabili locali.

Errore n. 3: denominazione errata delle costanti. Le costanti devono essere in MAIUSCOLO_SEPARATE_DA_UNDERSCORE. Una dichiarazione come final int maxUsers = 100; peggiora la leggibilità.

Errore n. 4: dimenticare l’ambito di visibilità. Una costante dichiarata all’interno di un metodo è visibile solo lì. Per usarla in tutta la classe, dichiarala a livello di classe come static final.

Errore n. 5: pensare che final renda immutabile l’oggetto. final fissa il riferimento, non lo stato dell’oggetto — sono cose diverse.