# Come funziona l’operatore instanceof di Java

L’operatore [Java](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/operatori-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](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/linguaggi-programmazione-web/), 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:

```java
(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”.

```java
public class Animale {
}
```

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

```java
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](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/comandi-java/) System.out.println:

```java
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:

```java
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.

```java
// 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:

```java
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:

```java
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à:

```java
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:

```java
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 è:

```java
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”.

```java
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
java.lang.Error: Unresolved compilation problem:
Incompatible conditional operand types Gatto and Cane
```

Consiglio Nella nostra Digital Guide sono disponibili altri interessanti tutorial e articoli informativi su Java. Ad esempio, trovi un confronto dettagliato tra [Java e JavaScript](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/java-e-javascript/), così come tra [Java e Python](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/python-vs-java/). Trovi anche un utile approfondimento sugli [operatori bitwise di Java](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/operatori-bitwise-di-java/).


This is a markdown version of: [https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/operatore-instanceof-di-java/](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/operatore-instanceof-di-java/) for AI/LLM consumption.