Come funziona l’operatore instanceof di Java

L’operatore Java instanceof può essere utilizzato per verificare la corrispondenza tra un oggetto e una classe. Esso fornisce questa informazione sotto forma di dichiarazione booleana, cioè “vero” o “falso”, e rappresenta una funzione di controllo utile per evitare la presenza di messaggi di errore nel codice.

Cos’è instanceof in Java?

Non tutte le variabili in Java sono così specifiche da rendere immediatamente evidente la loro natura. Soprattutto quando si crea un progetto esteso con numerose variabili nel linguaggio di programmazione, i dati di input, ad esempio, possono far sì che una variabile appaia come uno dei tanti oggetti presenti nel codice. Per questo motivo, Java mette a disposizione l’operatore instanceof. Questo garantisce che l’istanza (“instance” in inglese) di una variabile di riferimento corrisponda effettivamente a una classe, una sottoclasse o un’interfaccia. In questo caso, l’operatore restituisce il valore booleano “true” (vero). Se non c’è corrispondenza, l’output è “false” (falso).

In particolare, prima di convertire un oggetto sconosciuto, è consigliabile eseguire instanceof di Java per assicurarsi che l’oggetto appartenga alla classe prevista. Senza questo controllo di sicurezza, potrebbe essere emessa una ClassCastException. Questo messaggio di errore, che si verifica quando un oggetto deve essere convertito in un’altra classe, può causare confusione e problemi, soprattutto quando il codice è particolarmente esteso; per questo motivo è consigliabile eseguire un controllo di sicurezza in fase iniziale.

Funzionzionamento e sintassi

Al momento dell’esecuzione di instanceof in Java, l’operatore confronta una variabile di riferimento con una classe specifica specificata dall’utente. Non fa ulteriori dichiarazioni sulla natura dell’oggetto o della classe, ma si limita a determinare la presenza o meno di una corrispondenza. Anche la sintassi è molto semplice e si presenta come segue:

(oggetto) instanceof (classe)

Se (oggetto) è un’istanza di (classe), viene visualizzato “true”. In caso contrario, viene visualizzato “false”.

Esempio semplice di operatore instanceof in Java

Il modo più semplice per illustrare l’istanza di Java e il suo funzionamento è un breve esempio. Per farlo, creiamo innanzitutto una classe chiamata “Animale”.

public class Animale {
}

Nella fase successiva, estendiamo questa classe con una sottoclasse chiamata “Gatto”.

public class Gatto extends Animale {
}

Ora possiamo utilizzare instanceof per verificare se un’istanza di “Gatto” appartiene alla classe “Animale”. Per fare ciò, utilizziamo il comando Java System.out.println:

public class Animale {}
public class Gatto extends Animale {
public static void main(String args []{
Gatto Gatto = new Gatto();
System.out.println(Gatto instanceof Animale);
}
}

L’output dovrebbe apparire come segue:

true

Livelli multipli e classe Object

Il principio funziona anche con la classe main e altre sottoclassi. Per illustrarlo, scegliamo un altro esempio con diversi livelli ed estendiamo l’operatore instanceof di Java con l’istruzione if-else. I testi dopo le barre oblique sono commenti Java, finalizzati a illustrare i singoli passaggi ma irrilevanti per l’output.

// Classe 1
// Superclasse
public class Animale {
}
// Classe 2
// Sottoclasse
class Gatto extends Animale {
}
// Classe 3
// Classe main
class Main {
public static void main(String[] args)
Gatto Gatto1 = new Gatto();
if (Gatto1 instanceof Gatto)
	System.out.println ("Gatto1 è un’istanza di Gatto");
else
	System.out.println ("Gatto1 NON è un’istanza di Gatto");
if (Gatto1 instanceof Animale)
	System.out.println ("Gatto1 è un’istanza di Animale");
else
	System.out.println ("Gatto1 NON è un’istanza di Animale");
if (Gatto1 instanceof Object)
	System.out.println ("Gatto1 è un’istanza di Object");
else
	System.out.println ("Gatto1 NON è un’istanza di Object);
	}
}

Poiché “Gatto1” nel nostro esempio è un’istanza della classe “Gatto” e della superclasse “Animale”, a entrambe le interrogazioni viene risposto “true”. Poiché Object (o la classe “java.lang.Object”) si trova in cima alla gerarchia, anche “Gatto1” è un’istanza di Object. L’operatore instanceof di Java restituirà quindi sempre “true” se utilizzato con la classe Object. L’output corrispondente appare quindi come segue:

Gatto1 è un’istanza di Gatto
Gatto1 è un’istanza di Animale
Gatto1 è un’istanza di Object

Output con valore zero

Se una variabile ha valore 0, cioè non contiene un oggetto, l’operatore Java instanceof restituisce automaticamente “false”. Puoi verificarlo con il seguente esempio:

class Gatto {
}
class Main {
public static void main(String[] args)
{
Gatto Gatto2 = zero;
if (Gatto2 instanceof Gatto)
	System.out.println ("Gatto1 è un’istanza di Gatto");
else
	System.out.println ("Gatto1 NON è un’istanza di Gatto");
	}
}

L’output corrispondente sarà:

Gatto1 NON è un’istanza di Gatto

Le superclassi non sono un’istanza di una classe inferiore

Mentre nella gerarchia gli oggetti delle sottoclassi appartengono anche alle classi sovraordinate, questo principio non funziona all’inverso. Lo illustriamo nel seguente esempio:

class Animale {
}
class Gatto extends Animale {
}
class Main {
public static void main(String[] args)
{
Animale Bello = new Animale ();
if (Bello instanceof Gatto)
	System.out.println ("Bello è un’istanza di Gatto");
else
	System.out.println ("Bello NON è un’istanza di Gatto");
	}
}

L’output in questo caso è:

Bello NON è un’istanza di Gatto

Messaggio di errore per connessione mancante

Nel caso in cui non vi sia alcun collegamento tra l’oggetto e la classe con cui deve essere confrontato, viene visualizzato un messaggio di errore. Mostriamo anche questo con un esempio e creiamo una nuova classe chiamata “Cane”, che appartiene alla superclasse “Animale” ma non ha alcun collegamento con “Gatto”.

class Cane implements Animale {
}
class Main {
public static void main(String[] args)
{
Gatto Gatto3 = new Gatto ();
System.out.println (Gatto3 instanceof Cane);
	}
}

In questo caso, riceviamo un messaggio di errore che ci informa che non esiste una connessione tra le classi “Gatto” e “Cane”. Il messaggio si presenta come segue:

java.lang.Error: Unresolved compilation problem:
Incompatible conditional operand types Gatto and Cane