Come funziona l’operatore in­stan­ceof di Java

L’operatore Java in­stan­ceof può essere uti­liz­za­to per ve­ri­fi­ca­re la cor­ri­spon­den­za tra un oggetto e una classe. Esso fornisce questa in­for­ma­zio­ne sotto forma di di­chia­ra­zio­ne booleana, cioè “vero” o “falso”, e rap­pre­sen­ta una funzione di controllo utile per evitare la presenza di messaggi di errore nel codice.

Cos’è in­stan­ceof in Java?

Non tutte le variabili in Java sono così spe­ci­fi­che da rendere im­me­dia­ta­men­te evidente la loro natura. So­prat­tut­to quando si crea un progetto esteso con numerose variabili nel lin­guag­gio di pro­gram­ma­zio­ne, 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 di­spo­si­zio­ne l’operatore in­stan­ceof. Questo ga­ran­ti­sce che l’istanza (“instance” in inglese) di una variabile di ri­fe­ri­men­to cor­ri­spon­da ef­fet­ti­va­men­te a una classe, una sot­to­clas­se o un’in­ter­fac­cia. In questo caso, l’operatore re­sti­tui­sce il valore booleano “true” (vero). Se non c’è cor­ri­spon­den­za, l’output è “false” (falso).

In par­ti­co­la­re, prima di con­ver­ti­re un oggetto sco­no­sciu­to, è con­si­glia­bi­le eseguire in­stan­ceof di Java per as­si­cu­rar­si che l’oggetto ap­par­ten­ga alla classe prevista. Senza questo controllo di sicurezza, potrebbe essere emessa una Clas­sCa­stEx­cep­tion. Questo messaggio di errore, che si verifica quando un oggetto deve essere con­ver­ti­to in un’altra classe, può causare con­fu­sio­ne e problemi, so­prat­tut­to quando il codice è par­ti­co­lar­men­te esteso; per questo motivo è con­si­glia­bi­le eseguire un controllo di sicurezza in fase iniziale.

Fun­zion­zio­na­men­to e sintassi

Al momento dell’ese­cu­zio­ne di in­stan­ceof in Java, l’operatore confronta una variabile di ri­fe­ri­men­to con una classe specifica spe­ci­fi­ca­ta dall’utente. Non fa ulteriori di­chia­ra­zio­ni sulla natura dell’oggetto o della classe, ma si limita a de­ter­mi­na­re la presenza o meno di una cor­ri­spon­den­za. Anche la sintassi è molto semplice e si presenta come segue:

(oggetto) instanceof (classe)

Se (oggetto) è un’istanza di (classe), viene vi­sua­liz­za­to “true”. In caso contrario, viene vi­sua­liz­za­to “false”.

Esempio semplice di operatore in­stan­ceof in Java

Il modo più semplice per il­lu­stra­re l’istanza di Java e il suo fun­zio­na­men­to è un breve esempio. Per farlo, creiamo in­nan­zi­tut­to una classe chiamata “Animale”.

public class Animale {
}

Nella fase suc­ces­si­va, esten­dia­mo questa classe con una sot­to­clas­se chiamata “Gatto”.

public class Gatto extends Animale {
}

Ora possiamo uti­liz­za­re in­stan­ceof per ve­ri­fi­ca­re se un’istanza di “Gatto” ap­par­tie­ne alla classe “Animale”. Per fare ciò, uti­liz­zia­mo 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 sot­to­clas­si. Per il­lu­strar­lo, scegliamo un altro esempio con diversi livelli ed esten­dia­mo l’operatore in­stan­ceof di Java con l’istru­zio­ne if-else. I testi dopo le barre oblique sono commenti Java, fi­na­liz­za­ti a il­lu­stra­re i singoli passaggi ma ir­ri­le­van­ti 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 su­per­clas­se “Animale”, a entrambe le in­ter­ro­ga­zio­ni 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 in­stan­ceof di Java re­sti­tui­rà quindi sempre “true” se uti­liz­za­to con la classe Object. L’output cor­ri­spon­den­te 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 in­stan­ceof re­sti­tui­sce au­to­ma­ti­ca­men­te “false”. Puoi ve­ri­fi­car­lo 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 cor­ri­spon­den­te sarà:

Gatto1 NON è un’istanza di Gatto

Le su­per­clas­si non sono un’istanza di una classe inferiore

Mentre nella gerarchia gli oggetti delle sot­to­clas­si ap­par­ten­go­no anche alle classi so­vraor­di­na­te, questo principio non funziona all’inverso. Lo il­lu­stria­mo 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 con­nes­sio­ne mancante

Nel caso in cui non vi sia alcun col­le­ga­men­to tra l’oggetto e la classe con cui deve essere con­fron­ta­to, viene vi­sua­liz­za­to un messaggio di errore. Mostriamo anche questo con un esempio e creiamo una nuova classe chiamata “Cane”, che ap­par­tie­ne alla su­per­clas­se “Animale” ma non ha alcun col­le­ga­men­to 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 con­nes­sio­ne 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