Java in­s­tance­of: So prüfst du Ob­jekt­ty­pen korrekt

Mit dem Java-Operator in­s­tance­of prüfst du, ob ein Objekt zu einer be­stimm­ten Klasse passt. Der Operator liefert das Ergebnis als boole­schen Wert, also „true“ oder „false“. Durch diesen Check lassen sich Feh­ler­mel­dun­gen im Code effektiv vermeiden.

Was ist in­s­tance­of in Java?

In Java sind Variablen nicht immer so eindeutig, dass ihr Typ sofort klar ist. Besonders bei großen Projekten in der Pro­gram­mier­spra­che können etwa Input-Daten dazu führen, dass eine Variable ver­schie­de­ne Ob­jekt­ty­pen annehmen kann. Hier hilft der in­s­tance­of-Operator von world4you weiter. Er stellt sicher, dass die Instanz einer Re­fe­renz­va­ria­blen tat­säch­lich mit einer Klasse, Un­ter­klas­se oder Schnitt­stel­le über­ein­stimmt. Passt alles, gibt der Operator „true“ aus. Gibt es keine Über­ein­stim­mung, lautet das Ergebnis „false“.

Bevor du ein un­be­kann­tes Objekt um­wan­delst, solltest du unbedingt Java in­s­tance­of nutzen. So stellst du sicher, dass das Objekt wirklich zur er­war­te­ten Klasse gehört. Ohne diesen Check riskierst du eine ClassCastEx­cep­ti­on. Dieser Fehler tritt auf, wenn ein Objekt fälsch­li­cher­wei­se in eine andere Klasse kon­ver­tiert werden soll. Um Ver­wir­rung und Probleme im Code zu vermeiden, ist diese früh­zei­ti­ge Ab­si­che­rung der ideale Weg für einen rei­bungs­lo­sen Ablauf.

Funk­ti­ons­wei­se und Syntax

Wenn du in­s­tance­of in Java einsetzt, ver­gleicht der Operator eine Re­fe­renz­va­ria­ble mit einer von dir de­fi­nier­ten Klasse. Er gibt keine Details zur Be­schaf­fen­heit aus, sondern prüft lediglich die Über­ein­stim­mung. Die Syntax ist dabei denkbar einfach gehalten:

(objekt) instanceof (klasse)

Ist (objekt) eine Instanz von (klasse), erhältst du „true“. Falls nicht, erscheint „false“.

Einfaches Beispiel für den in­s­tance­of-Operator

Die Funk­ti­ons­wei­se von Java in­s­tance­of lässt sich am besten an einem kurzen Beispiel zeigen. Zuerst erstellen wir die Klasse „Tier“.

public class Tier {
}

Danach erweitern („extend“) wir diese um die Un­ter­klas­se „Katze“.

public class Katze extends Tier {
}

Mit Java in­s­tance­of prüfen wir nun, ob eine Instanz von „Katze“ zur Klasse „Tier“ gehört. Das erledigen wir mit den folgenden Zeilen und nutzen den Java-Befehl System.out.println für die Ausgabe:

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

Das Ergebnis sieht so aus:

true

Hier­ar­chien und die Object-Klasse

Das System greift auch bei der Main-Klasse und weiteren Ebenen. Wir erweitern unser Beispiel und nutzen den in­s­tance­of-Operator mit der Anweisung if-else. Die Texte nach den Schräg­stri­chen sind Java Comments. Sie dienen der Erklärung und be­ein­flus­sen die Ausgabe nicht.

// Klasse 1
// Oberklasse
public class Tier {
}
// Klasse 2
// Unterklasse
class Katze extends Tier {
}
// Klasse 3
// Main-Klasse
class Main {
public static void main(String[] args)
Katze Katze1 = new Katze();
if (Katze1 instanceof Katze)
	System.out.println ("Katze1 ist eine Instanz von Katze");
else
	System.out.println ("Katze1 ist KEINE Instanz von Katze");
if (Katze1 instanceof Tier)
	System.out.println ("Katze1 ist eine Instanz von Tier");
else
	System.out.println ("Katze1 ist KEINE Instanz von Tier");
if (Katze1 instanceof Object)
	System.out.println ("Katze1 ist eine Instanz von Object");
else
	System.out.println ("Katze1 ist KEINE Instanz von Object);
	}
}

Da „Katze1“ sowohl zur Klasse „Katze“ als auch zur Ober­klas­se „Tier“ gehört, liefern beide Abfragen „true“. Da die Klasse „java.lang.Object“ an der Spitze der Hier­ar­chie steht, ist „Katze1“ au­to­ma­tisch auch eine Instanz davon. Der Java in­s­tance­of Operator gibt bei der Object-Klasse also immer „true“ aus. Die Ausgabe bestätigt das:

Katze1 ist eine Instanz von Katze
Katze1 ist eine Instanz von Tier
Katze1 ist eine Instanz von Object

Umgang mit Null-Werten

Hat eine Variable den Wert 0 (enthält also kein Objekt), gibt der Java-Operator in­s­tance­of au­to­ma­tisch „false“ zurück. Das lässt sich einfach testen:

class Katze {
}
class Main {
public static void main(String[] args)
{
Katze Katze2 = null;
if (Katze2 instanceof Katze)
	System.out.println ("Katze1 ist eine Instanz von Katze");
else
	System.out.println ("Katze1 ist KEINE Instanz von Katze");
	}
}

Die Ausgabe dazu lautet:

Katze1 ist KEINE Instanz von Katze

Ober­klas­sen sind keine Instanz ihrer Un­ter­klas­sen

Objekte von Un­ter­klas­sen gehören zwar zur Ober­klas­se, umgekehrt gilt das jedoch nicht. Das folgende Beispiel ver­deut­licht diesen Punkt:

class Tier {
}
class Katze extends Tier {
}
class Main {
public static void main(String[] args)
{
Tier Bello = new Tier ();
if (Bello instanceof Katze)
	System.out.println ("Bello ist eine Instanz von Katze");
else
	System.out.println ("Bello ist KEINE Instanz von Katze");
	}
}

In diesem Fall sieht die Ausgabe so aus:

Bello ist KEINE Instanz von Katze

Fehler bei fehlender Ver­bin­dung

Besteht keinerlei Ver­bin­dung zwischen dem Objekt und der Klasse, führt dies zu einer Feh­ler­mel­dung. Wir erstellen dafür die Klasse „Hund“. Diese gehört zwar auch zur Ober­klas­se „Tier“, hat aber keinen Bezug zur Klasse „Katze“.

class Hund implements Tier {
}
class Main {
public static void main(String[] args)
{
Katze Katze3 = new Katze ();
System.out.println (Katze3 instanceof Hund);
	}
}

Das System meldet nun, dass zwischen „Katze“ und „Hund“ keine Ver­bin­dung existiert. Die Meldung wird so angezeigt:

java.lang.Error: Unresolved compilation problem:
Incompatible conditional operand types Katze and Hund

58ae44c97ddd65c04c28258d57ac2e42 341cbc51f31aa6f9652128aaf175d3f6