Java Academy · Lezione

Pattern matching per instanceof

Associare una variabile durante il controllo del tipo

Pattern matching per instanceof è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Pattern matching per instanceof

Il vecchio modo di usare instanceof consisteva nel verificare il tipo e poi fare il cast. Il pattern matching combina il controllo e il cast in un unico passaggio, associando una variabile tipizzata quando il controllo ha esito positivo.

Il codice ripetitivo tradizionale

Il codice classico verifica il tipo e poi fa il cast in una nuova variabile. È ripetitivo e facile da scrivere in modo errato.

public class Main {
    public static void main(String[] args) {
        Object obj = "hello";
        if (obj instanceof String) {
            String s = (String) obj;
            System.out.println(s.length());
        }
    }
}

La nuova forma

Un pattern di tipo dichiara la variabile direttamente nell'espressione: if (obj instanceof String s). Quando la condizione è vera, s contiene già il valore sottoposto a cast.

public class Main {
    public static void main(String[] args) {
        Object obj = "hello";
        if (obj instanceof String s) {
            System.out.println(s.length());
        }
    }
}

La variabile associata

La variabile s è chiamata variabile di pattern. È nell'ambito in tutti i punti in cui il compilatore può dimostrare che il pattern ha avuto successo, rendendo il codice più breve e sicuro.

Usarla nelle condizioni

Nella stessa condizione if si può usare la variabile di pattern dopo &&, perché in quel ramo la corrispondenza è garantita.

public class Main {
    public static void main(String[] args) {
        Object obj = "developer";
        if (obj instanceof String s && s.length() > 5) {
            System.out.println("Long string: " + s);
        }
    }
}

Negazione e ambito determinato dal flusso

Con la negazione, l'ambito cambia in modo intelligente. Dopo if (!(obj instanceof String s)) return;, la variabile s è nell'ambito per il resto del metodo, perché il codice prosegue solo quando la corrispondenza ha avuto successo.

public class Main {
    static int safeLength(Object obj) {
        if (!(obj instanceof String s)) {
            return -1;
        }
        return s.length();
    }

    public static void main(String[] args) {
        System.out.println(safeLength("abc"));
        System.out.println(safeLength(42));
    }
}

Sostituire equals e il cast

Un uso tipico è una semplice ridefinizione di equals: si verifica il tipo e si associa la variabile in una sola riga, quindi si confrontano i campi.

public class Main {
    static final class Point {
        final int x, y;
        Point(int x, int y) { this.x = x; this.y = y; }
        public boolean equals(Object o) {
            return o instanceof Point p && p.x == x && p.y == y;
        }
        public int hashCode() { return x * 31 + y; }
    }

    public static void main(String[] args) {
        System.out.println(new Point(1, 2).equals(new Point(1, 2)));
        System.out.println(new Point(1, 2).equals(new Point(3, 4)));
    }
}

Gestire tipi diversi

Le ramificazioni concatenate else if con pattern consentono di gestire in modo chiaro diversi tipi possibili.

public class Main {
    static String describe(Object obj) {
        if (obj instanceof Integer i) {
            return "int " + (i * 2);
        } else if (obj instanceof String s) {
            return "string of length " + s.length();
        } else {
            return "unknown";
        }
    }

    public static void main(String[] args) {
        System.out.println(describe(21));
        System.out.println(describe("hello"));
        System.out.println(describe(3.14));
    }
}

Null non viene mai riconosciuto

Un pattern instanceof è false per null, proprio come l'operatore classico. Pertanto la variabile del pattern non viene mai associata a null, eliminando una causa comune di NPE.

public class Main {
    public static void main(String[] args) {
        Object obj = null;
        if (obj instanceof String s) {
            System.out.println("matched: " + s);
        } else {
            System.out.println("null or not a String");
        }
    }
}

Codice più chiaro e sicuro

Il pattern matching elimina il cast ridondante, limita l'ambito in modo da impedire l'uso improprio della variabile e si legge quasi come l'inglese. È lo stile preferito nel Java moderno.

Mettere tutto insieme

Un piccolo dispatcher che formatta input diversi usando i pattern.

public class Main {
    static String format(Object o) {
        if (o instanceof Double d) return String.format("%.1f", d);
        if (o instanceof Integer i) return Integer.toString(i);
        if (o instanceof String s && !s.isBlank()) return s.trim();
        return "n/a";
    }

    public static void main(String[] args) {
        System.out.println(format(3.14159));
        System.out.println(format(99));
        System.out.println(format("  spaced  "));
        System.out.println(format(null));
    }
}

Verifica rapida

Verifichi la Sua comprensione dei pattern instanceof.

Riepilogo

Ha imparato il pattern matching per instanceof.

Unisce il controllo del tipo e il cast in un'unica espressione.
L'ambito della variabile del pattern si estende al punto in cui la corrispondenza è verificata.
I pattern restituiscono false per null, evitando gli NPE.
Semplificano gli override di equals e il dispatch in base al tipo.

Domande Frequenti

La lezione «Pattern matching per instanceof» è gratuita?

Sì — il testo completo di «Pattern matching per instanceof» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Pattern matching per instanceof»?

Associare una variabile durante il controllo del tipo Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Pattern matching per instanceof»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Java Academy