Hur Java-operatorn in­stan­ce­of fungerar

Du kan använda Java-operatorn instanceof för att kon­trol­le­ra om ett objekt tillhör en viss klass. Ope­ra­tö­ren ger svaret i form av ett booleskt uttryck, dvs. ”sant” eller ”falskt”. Genom att i förväg kon­trol­le­ra om objektet och klassen matchar kan du undvika fel­med­de­lan­den senare.

Vad är instanceof i Java?

Vissa va­ri­ablers natur i Java är inte alltid ome­del­bart 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 pro­gram­me­rings­språ­ket förser an­vän­dar­na med instanceof. Denna Java-operator sä­ker­stäl­ler att instansen av en re­fe­ren­sva­ri­a­bel verkligen motsvarar en klass, un­der­klass eller gräns­snitt. Om det finns en matchning ger operatorn det booleska värdet ”true”. Om det inte finns någon matchning blir re­sul­ta­tet ”false”.

När du kon­ver­te­rar ett okänt objekt är det viktigt att använda Java instanceof för att sä­ker­stäl­la att objektet tillhör den antagna klassen. Om du hoppar över denna sä­ker­hets­kon­troll kan ett Clas­sCas­tEx­cep­tion-fel uppstå. Detta inträffar när ett objekt behöver kon­ver­te­ras till en annan klass. Fel­med­de­lan­det kan vara för­vir­ran­de 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ä­ker­hets­åt­gärd.

Vad är syntaxen för instanceof?

När du använder instanceof i Java jämför operatorn en re­fe­ren­sva­ri­a­bel med en specifik klass som också anges av an­vän­da­ren. Den in­ne­hål­ler ingen yt­ter­li­ga­re in­for­ma­tion 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 de­mon­stre­ra 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 un­der­klass som heter “Cat”.

public class Cat extends Animal {
}

Nu kan vi använda Java instanceof för att kon­trol­le­ra om en instans av Cat tillhör klassen Animal. För att göra detta skriver vi några rader kod och visar re­sul­ta­tet 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);
}
}

Re­sul­ta­tet ska se ut så här:

true

Flera nivåer och klassen Object

Denna princip fungerar även med Main-klassen och andra un­der­klas­ser. Nästa exempel in­ne­hål­ler flera nivåer och vi har utökat operatorn instanceof i Java med if-else. Du kanske märker att det finns yt­ter­li­ga­re text efter två sned­streck (//). Det är Java-kom­men­ta­rer. De förklarar de enskilda stegen men påverkar inte re­sul­ta­tet.

// 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 su­per­klas­sen 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-ope­ra­tö­ren instanceof alltid att ge re­sul­ta­tet true när den används med klassen Object. Re­sul­ta­tet 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 in­ne­hål­ler något objekt) matar Java-operatorn instanceof au­to­ma­tiskt 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 re­sul­ta­tet:

cat2 is NOT an instance of Cat

Överklass/un­der­klass

Även om objekt i un­der­klas­ser också tillhör un­der­klas­sens mot­sva­ran­de över­klas­ser, fungerar det inte tvärtom. Följande exempel il­lu­stre­rar denna aspekt av klas­struk­tur:

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 re­sul­ta­tet:

Bello is NOT an instance of Cat

Fel­med­de­lan­de för in­kom­pa­tib­la typer

Om det inte finns någon koppling mellan ett objekt och en klass visas ett fel­med­de­lan­de. För att il­lu­stre­ra detta skapar vi en ny klass som heter “Dog” som tillhör su­per­klas­sen 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 fel­med­de­lan­de som talar om att det inte finns någon koppling mellan klasserna Cat och Dog. Med­de­lan­det ser ut så här:

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