# Hoe de Java-operator instanceof werkt

Je kunt de Java-operator `instanceof` gebruiken om te controleren of een object tot een bepaalde klasse behoort. De operator geeft het antwoord in de vorm van een Booleaanse uitspraak, d.w.z. ‘waar’ of ‘onwaar’. Door vooraf te controleren of het object en de klasse overeenkomen, kun je later foutmeldingen voorkomen.

## Wat is `instanceof` in Java?

De aard van sommige variabelen in Java is niet altijd meteen duidelijk. In grote Java-projecten met talrijke variabelen kunnen invoergegevens er bijvoorbeeld voor zorgen dat een variabele als verschillende objecten verschijnt. Daarom biedt de programmeertaal gebruikers `instanceof`. Deze Java-operator zorgt ervoor dat de **instantie** van een referentievariabele echt overeenkomt met een klasse, subklasse of interface. Als er een overeenkomst is, geeft de operator de Booleaanse waarde ‘true’ weer. Als er geen overeenkomst is, is de uitvoer ‘false’.

Bij het converteren van een onbekend object is het belangrijk om Java `instanceof` te gebruiken om ervoor te zorgen dat het object tot de veronderstelde klasse behoort. Als u deze veiligheidscontrole overslaat, kan er een **ClassCastException** worden gegenereerd. Dit gebeurt wanneer een object naar een andere klasse moet worden geconverteerd. De foutmelding kan verwarrend zijn en problemen veroorzaken als de code bijzonder lang is. Daarom is het het beste om Java `instanceof` in een vroeg stadium te gebruiken als voorzorgsmaatregel.

## Wat is de syntaxis voor `instanceof`?

Wanneer u `instanceof` in Java gebruikt, **vergelijkt** de operator **een referentievariabele met een specifieke klasse** die ook door de gebruiker is opgegeven. Het bevat geen aanvullende informatie over de aard van het object of de klasse. Het bepaalt alleen of er een overeenkomst is of niet. De syntaxis is eenvoudig en ziet er als volgt uit:

```java
(object) instanceof (class)
```

Als `(object)` een instantie is van `(class)`, wordt ‘waar’ weergegeven. Als dit niet het geval is, wordt ‘onwaar’ weergegeven.

## Voorbeelden van `instanceof` operatoren in Java

Eerst laten we u een kort voorbeeld zien om te demonstreren hoe `instanceof` werkt in Java. Hier maken we een klasse aan met de naam ‘Animal’.

```java
public class Animal {
}
```

De volgende stap is om deze klasse uit te breiden met een subklasse genaamd ‘Cat’.

```java
public class Cat extends Animal {
}
```

Nu kunnen we Java `instanceof` gebruiken om te controleren of een instantie van Cat tot de klasse Animal behoort. Hiervoor schrijven we nog enkele regels code en geven we het resultaat weer met Java-commando `System.out.println`:

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

De uitvoer zou er als volgt uit moeten zien:

```java
true
```

### Meerdere niveaus en de Object-klasse

Dit principe werkt ook met de Main-klasse en andere subklassen. Het volgende voorbeeld bevat verschillende niveaus en we hebben de `instanceof` in Java uitgebreid met `if-else`. Je ziet misschien wat extra tekst achter twee schuine strepen (//). Dit zijn [Java-opmerkingen](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-opmerkingen/). Ze geven uitleg over de afzonderlijke stappen, maar hebben geen invloed op de uitvoer.

```java
// 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");
	}
}
```

Als we naar ons voorbeeld kijken, zien we dat cat1 een instantie is van de klasse Cat en de superklasse Animal. Als zodanig is het antwoord op beide vragen ‘true’. Aangezien Object, of klasse `java.lang.Object`, bovenaan de hiërarchie staat, is cat1 ook een instantie van Object. De `instanceof` zal dus altijd true uitvoeren wanneer deze wordt gebruikt met de klasse Object. De uitvoer ziet er als volgt uit:

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

### Uitvoer met een null-waarde

Als een variabele een null-waarde heeft (d.w.z. geen object bevat), geeft de Java-operator `instanceof` automatisch ‘false’ weer. Laten we eens kijken hoe dit werkt aan de hand van het volgende voorbeeld:

```java
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");
	}
}
```

De uitvoer in dit geval is:

```java
cat2 is NOT an instance of Cat
```

### Superklasse/subklasse

Hoewel objecten in subklassen ook behoren tot de overeenkomstige superklassen van de subklasse, geldt dit niet andersom. Het volgende voorbeeld illustreert dit aspect van de klassenhiërarchie:

```java
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");
	}
}
```

De uitvoer in dit geval is:

```java
Bello is NOT an instance of Cat
```

### Foutmelding voor incompatibele typen

Als er geen verband bestaat tussen een object en een klasse, wordt er een foutmelding weergegeven. Om dit te illustreren, maken we een nieuwe klasse aan met de naam ‘Dog’, die behoort tot de superklasse Animal, maar geen verband houdt met Cat.

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

In deze situatie krijgen we een foutmelding te zien waarin staat dat er geen verband bestaat tussen de klassen Cat en Dog. De melding ziet er als volgt uit:

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

Tip In onze digitale gids vindt u meer interessante tutorials en informatieve artikelen over Java. U vindt er een vergelijking tussen [Java en JavaScript](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-versus-javascript/) en een vergelijking tussen [Java en Python](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/python-versus-java/). U kunt ook meer te weten komen over [Java-bitwise-operatoren](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-bitgewijze-operatoren/).


This is a markdown version of: [https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-operator-instanceof/](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-operator-instanceof/) for AI/LLM consumption.