Parola Chiave instanceof Java

In questo tutorial, attraverso esempi, imparerai a conoscere meglio l'operatore instanceof in Java.

In Java, la parola chiave instanceof è un operatore binario. Viene utilizzato per verificare se un oggetto è un'istanza di una classe specifica.

L'operatore verifica anche se l'oggetto è un'istanza della classe che implementa un'interfaccia (sarà discusso in seguito in questo tutorial).

La sintassi dell'operatore instanceof è:

result = objectName instanceof className;

　L'operando sinistro dell'operatore instanceof è il nome dell'oggetto, quello destro è il nome della classe. Se l'oggetto è un'istanza della classe, il risultato è true; altrimenti, è false.

Esempio 1: instanceof

class Main {
　　　　public static void main(String[] args) {
　　　　　　　　String name = "w3codebox";
　　　　　　　　Integer age = 22;
　　　　　　　　System.out.println("name è un'istanza di String: " + (name instanceof String));
　　　　　　　　System.out.println("age è un'istanza di Integer: " + (age instanceof Integer));
　　　　}
}

Output:

name è un'istanza di String: true
age è un'istanza di Integer: true

Nell'esempio sopra, abbiamo creato un oggetto di tipo String name e un altro oggetto di tipo Integer age. Poi, abbiamo utilizzato l'operatore instanceof per verificare se il nome è di tipo String e se l'età è di tipo Integer.

instanceof e Ereditarietà

Nel caso dell'ereditarietà, l'operatore instanceof viene utilizzato per verificare se l'oggetto della sottoclasse è anche un'istanza dell'astratto.

Esempio 2: instanceof nell'ereditarietà

class Animal {
}
//La classe Dog è una sottoclasse della classe Animal
class Dog extends Animal {
}
class Main {
　　　　public static void main(String[] args){
　　　　　　　　Dog d1 = new Dog();
　　　　　　　　//Verifica se d1 è un oggetto di Dog
　　　　　　　　System.out.println("d1 è un'istanza di Dog: "+ (d1 instanceof Dog));
　　　　　　　
　　　　　　　　//Verifica se d1 è un oggetto di Animal
　　　　　　　　System.out.println("d1 è un'istanza di Animal: "+ (d1 instanceof Animal));
　　　　}
}

Output:

d1 è un'istanza di Dog: true
d1 è un'istanza di Animal: true

Nell'esempio sopra, d1 è un'istanza delle classi Dog e Animal. Pertanto, sia d1 instanceof Dog che d1 instanceof Animal sono true.

Classe Object

In Java, tutte le classi derivano dalla classe Object, l'ereditarietà della classe Object non utilizza la parola chiave extends. Questa ereditarietà avviene implicitamente in Java.

Esempio 3: Classe Object

class Animal {
}
class Dog {
}
class Cat {
}
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Dog d1 = new Dog();
　　　　　　　　Animal a1 = new Animal();
　　　　　　　　Cat c1 = new Cat();
　　　　　　　　System.out.println("d1 è un'istanza della classe Object: "+ (d1 instanceof Object));
　　　　　　　　System.out.println("a1 è un'istanza della classe Object: "+ (a1 instanceof Object));　　　
　　　　　　　　System.out.println("c1 è un'istanza della classe Object: "+ (c1 instanceof Object));
　　　　}
}

Output:

d1 è un'istanza della classe Object: true
a1 è un'istanza della classe Object: true
c1 è un'istanza della classe Object: true

Nell'esempio sopra, abbiamo creato gli oggetti delle classi Animal, Dog e Cat, rispettivamente a1, d1 e c1. Abbiamo già utilizzato l'operatore instanceof per verificare se gli oggetti a1, d1, c1 sono anche oggetti della classe Object. Il risultato dell'output è sempre true (vero).

Questo è perché la classe Object è definita nel pacchetto java.lang. Tutte le altre classi sono sottoclassi della classe Object, che forma una struttura gerarchica in Java.

Transizione di oggetto verso l'alto e verso il basso

In Java, l'oggetto di una sottoclasse può essere considerato come un oggetto di superclasse. Questo si chiama转型向上.In modo通俗地 si intende la conversione di un oggetto di sottoclasse in un oggetto di superclasse. In questo caso, l'oggetto di superclasse può essere un'interfaccia.

Il compilatore Java esegue automaticamente la trasformazione di tipo verso l'alto.

Esempio 4: Trasformazione di tipo verso l'alto dell'oggetto

class Animal {
　　　　public void displayInfo() {
　　　　　　　　System.out.println("Io sono un animale.");
　　　　}
}
class Dog extends Animal {
}
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Dog d1 = new Dog();
　　　　　　　　Animal a1 = d1;
　　　　　　　　a1.displayInfo();
　　　　}
}

Output:

Io sono un animale.

Nell'esempio precedente, abbiamo creato un oggetto della classe Dog chiamato d1. Abbiamo utilizzato l'oggetto d1 per creare un oggetto della classe Animal chiamato a1. Questo in Java si chiama trasformazione di tipo verso l'alto.

Questo codice esegue senza problemi. Questo perché la trasformazione di tipo verso l'alto viene eseguita automaticamente dal compilatore Java.

La trasformazione di tipo verso il basso è il processo opposto alla trasformazione di tipo verso l'alto, ossia opposto alla trasformazione di tipo verso l'alto, ovvero convertire l'oggetto della superclasse in un oggetto della sottoclasse.

Nel caso della trasformazione di tipo verso il basso, l'oggetto della superclasse viene considerato come un oggetto della sottoclasse. Dobbiamo indicare esplicitamente al compilatore di Java di eseguire la trasformazione di tipo verso il basso.

Esempio 5: Problemi di trasformazione di tipo verso il basso dell'oggetto

class Animal {
}
class Dog extends Animal {
　　　public void displayInfo() {
　　　　　　　System.out.println("Io sono un cane.");
　　　}
}
class Main {
　　　public static void main(String[] args) {
　　　　　　　Animal a1 = new Animal();
　　　　　　　Dog d1 = (Dog)a1; // Trasformazione di tipo verso il basso
　
　　　　　　　d1.displayInfo();
　　　}
}

Eseguendo il programma, otterremo un'eccezione di tipo ClassCastException. Vediamo cosa è successo qui.

In questo esempio, abbiamo creato un oggetto della superclasse Animal chiamato a1. Poi abbiamo tentato di convertire l'oggetto a1 in un oggetto della sottoclasse Dog chiamato d1.

Questo ha causato un problema. Questo perché l'oggetto a1 della superclasse Animal potrebbe riferirsi anche ad altri sottogetti. Se creiamo un altro sottooggetto Cat insieme a Dog, l'animale potrebbe essere un gatto o un cane, causando ambiguità.

Per risolvere questo problema, possiamo utilizzare l'operatore instanceof. Ecco come si fa:

Esempio 6: Utilizzo di instanceof per risolvere la trasformazione di tipo verso il basso

class Animal {
}
class Dog extends Animal {
　　public void displayInfo() {
　　　　　System.out.println("Io sono un cane");
　　}
}
class Main {
　　public static void main(String[] args) {
　　　　Dog d1 = new Dog();
　　　　Animal a1 = d1; // Trasformazione di tipo verso l'alto
　　　　if (a1 instanceof Dog) {
　　　　　　　Dog d2 = (Dog)a1; // Trasformazione di tipo verso il basso
　　　　　　　d2.displayInfo();
　　　　}
　　}
}

Output:

Io sono un cane

Nell'esempio precedente, abbiamo utilizzato l'operatore instanceof per verificare se l'oggetto a1 è un'istanza della classe Dog. La trasformazione di tipo verso il basso avviene solo se l'espressione a1 instanceof Dog è true.

Interfaccia e instanceof

L'operatore instanceof viene anche utilizzato per verificare se l'oggetto di una classe è anche un'istanza dell'interfaccia che implementa la classe.

Esempio 7: instanceof nell'interfaccia

interface Animal {
}
class Dog implements Animal {
}
class Main {
　　　public static void main(String[] args) {
　　　　　　Dog d1 = new Dog();
　　　　　　System.out.println("L'oggetto d1 è un'istanza di Animal:　"+(d1 instanceof Animal));
　　　}
}

Output:

L'oggetto d1 è un'istanza di Animal:　true

Nell'esempio sopra, abbiamo creato una classe che implements l'interfaccia Animal.

Poi, crea l'oggetto della classe Dog d1. Abbiamo già utilizzato l'operatore instanceof per verificare se l'oggetto d1 è anche un'istanza dell'interfaccia Animal.