Hur Java-operatorn instanceof fungerar

Du kan använda Java-operatorn instanceof för att kontrollera om ett objekt tillhör en viss klass. Operatören ger svaret i form av ett booleskt uttryck, dvs. ”sant” eller ”falskt”. Genom att i förväg kontrollera om objektet och klassen matchar kan du undvika felmeddelanden senare.

Vad är instanceof i Java?

Vissa variablers natur i Java är inte alltid omedelbart uppenbar. I stora Java-projekt med många variabler kan till exempel indata göra att en variabel visas som olika objekt. Det är därför programmeringsspråket förser användarna med instanceof. Denna Java-operator säkerställer att instansen av en referensvariabel verkligen motsvarar en klass, underklass eller gränssnitt. Om det finns en matchning ger operatorn det booleska värdet ”true”. Om det inte finns någon matchning blir resultatet ”false”.

När du konverterar ett okänt objekt är det viktigt att använda Java instanceof för att säkerställa att objektet tillhör den antagna klassen. Om du hoppar över denna säkerhetskontroll kan ett ClassCastException-fel uppstå. Detta inträffar när ett objekt behöver konverteras till en annan klass. Felmeddelandet kan vara förvirrande och orsaka problem om koden är särskilt lång. Därför är det bäst att använda Java instanceof tidigt som en säkerhetsåtgärd.

Vad är syntaxen för instanceof?

När du använder instanceof i Java jämför operatorn en referensvariabel med en specifik klass som också anges av användaren. Den innehåller ingen ytterligare information om objektets eller klassens natur. Den avgör helt enkelt om det finns en matchning eller inte. Syntaxen är enkel och ser ut så här:

(object) instanceof (class)

Om (object) är en instans av (class) visas “true”. Om så inte är fallet visas “false”.

Exempel på operatorn instanceof i Java

Först visar vi ett kort exempel för att demonstrera hur instanceof fungerar i Java. Här skapar vi en klass som heter “Animal”.

public class Animal {
}

Nästa steg är att utöka denna klass med en underklass som heter “Cat”.

public class Cat extends Animal {
}

Nu kan vi använda Java instanceof för att kontrollera om en instans av Cat tillhör klassen Animal. För att göra detta skriver vi några rader kod och visar resultatet med Java-kommandot System.out.println:

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

Resultatet ska se ut så här:

true

Flera nivåer och klassen Object

Denna princip fungerar även med Main-klassen och andra underklasser. Nästa exempel innehåller flera nivåer och vi har utökat operatorn instanceof i Java med if-else. Du kanske märker att det finns ytterligare text efter två snedstreck (//). Det är Java-kommentarer. De förklarar de enskilda stegen men påverkar inte resultatet.

// Class 1
// Superclass
public class Animal {
}
// Class 2
// Subclass
class Cat extends Animal {
}
// Class 3
// Main class
class Main {
public static void main(String[] args)
Cat cat1 = new Cat();
if (cat1 instanceof Cat)
	System.out.println ("cat1 is an instance of Cat");
else
	System.out.println ("cat1 is NOT an instance of Cat");
if (cat1 instanceof Animal)
	System.out.println ("cat1 is an instance of Animal");
else
	System.out.println ("cat1 is NOT an instance of Animal");
if (cat1 instanceof Object)
	System.out.println ("cat1 is an instance of Object");
else
	System.out.println ("cat1 is NOT an instance of Object");
	}
}

Om vi tittar på vårt exempel kan vi se att cat1 är en instans av klassen Cat och superklassen Animal. Därför är svaret på båda frågorna ”true”. Eftersom Object, eller klassen java.lang.Object, ligger högst upp i hierarkin är cat1 också en instans av Object. Således kommer Java-operatören instanceof alltid att ge resultatet true när den används med klassen Object. Resultatet ser ut så här:

cat1 is an instance of Cat
cat1 is an instance of Animal
cat1 is an instance of Object

Utdata med ett nollvärde

Om en variabel har ett null-värde (dvs. inte innehåller något objekt) matar Java-operatorn instanceof automatiskt ut ”false”. Låt oss titta på hur detta fungerar med följande exempel:

class Cat {
}
class Main {
public static void main(String[] args)
{
Cat cat2 = null;
if (cat2 instanceof Cat)
	System.out.println ("cat2 is an instance of Cat");
else
	System.out.println ("cat2 is NOT an instance of Cat");
	}
}

I detta fall är resultatet:

cat2 is NOT an instance of Cat

Överklass/underklass

Även om objekt i underklasser också tillhör underklassens motsvarande överklasser, fungerar det inte tvärtom. Följande exempel illustrerar denna aspekt av klasstruktur:

class Animal {
}
class Cat extends Animal {
}
class Main {
public static void main(String[] args)
{
Animal bello = new Animal ();
if (bello instanceof Cat)
	System.out.println ("Bello is an instance of Cat");
else
	System.out.println ("Bello is NOT an instance of Cat");
	}
}

I detta fall är resultatet:

Bello is NOT an instance of Cat

Felmeddelande för inkompatibla typer

Om det inte finns någon koppling mellan ett objekt och en klass visas ett felmeddelande. För att illustrera detta skapar vi en ny klass som heter “Dog” som tillhör superklassen Animal men som inte har någon koppling till Cat.

class Dog extends Animal {
}
class Main {
public static void main(String[] args)
{
Cat cat3 = new Cat ();
System.out.println (cat3 instanceof Dog);
	}
}

I det här fallet får vi ett felmeddelande som talar om att det inte finns någon koppling mellan klasserna Cat och Dog. Meddelandet ser ut så här:

java.lang.Error: Unresolved compilation problem:
Incompatible conditional operand types Cat and Dog