# Sådan fungerer Java-operatoren instanceof

1

## Hvad er `instanceof` i Java?

Nogle variablers natur i Java er ikke altid umiddelbart indlysende. I store Java-projekter med mange variabler kan indtastningsdata for eksempel få en variabel til at fremstå som forskellige objekter. Derfor giver programmeringssproget brugerne `instanceof`. Denne Java-operator sikrer, at **instansen** af en referencevariabel virkelig svarer til en klasse, underklasse eller grænseflade. Hvis der er et match, udgiver operatoren den boolske værdi ‘true’. Hvis der ikke er noget match, er udgangen ‘false’.

Når du konverterer et ukendt objekt, er det vigtigt at bruge Java `instanceof` for at sikre, at objektet tilhører den antagne klasse. Hvis du springer denne sikkerhedskontrol over, kan der opstå en **ClassCastException**. Dette sker, når et objekt skal konverteres til en anden klasse. Fejlmeddelelsen kan være forvirrende og kan forårsage problemer, hvis koden er særlig lang. Derfor er det bedst at bruge Java `instanceof` tidligt som en sikkerhedsforanstaltning.

## Hvad er syntaksen for `instanceof`?

Når du bruger `instanceof` i Java, **sammenligner** operatoren **en referencevariabel med en bestemt klasse**, der også er angivet af brugeren. Den indeholder ikke yderligere oplysninger om objektets eller klassens art. Den afgør blot, om der er et match eller ej. Syntaksen er enkel og ser således ud:

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

Hvis `(object)` er en instans af `(class)`, vises ‘true’. Hvis dette ikke er tilfældet, vises ‘false’.

## Eksempler på `instanceof` i Java

Først viser vi dig et kort eksempel på, hvordan `instanceof` fungerer i Java. Her opretter vi en klasse kaldet ‘Animal’.

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

Det næste trin er at udvide denne klasse med en underklasse kaldet ‘Cat’.

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

Nu kan vi bruge Java `instanceof` til at kontrollere, om en instans af Cat tilhører klassen Animal. For at gøre dette skriver vi nogle flere linjer kode og udskriver resultatet med Java-kommandoen `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);
}
}
```

Resultatet skal se sådan ud:

```java
true
```

### Flere niveauer og objektklassen

Dette princip fungerer også med Main-klassen og andre underklasser. Det næste eksempel indeholder flere niveauer, og vi har udvidet `instanceof` i Java med `if-else`. Du vil måske bemærke, at der er tilføjet noget ekstra tekst efter to skråstreger (//). Dette er [Java-kommentarer](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-kommentarer/). De forklarer de enkelte trin, men har ingen indflydelse på outputtet.

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

Når vi ser på vores eksempel, kan vi se, at cat1 er en instans af klassen Cat og superklassen Animal. Som sådan er svaret på begge spørgsmål ‘true’. Da Object, eller klassen `java.lang.Object`, er øverst i hierarkiet, er cat1 også en instans af Object. Så `instanceof` operatoren vil altid give true, når den bruges med klassen Object. Outputtet ser sådan ud:

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

### Output med en null-værdi

Hvis en variabel har en null-værdi (dvs. ikke indeholder et objekt), udgiver Java-operatoren `instanceof` automatisk ‘false’. Lad os se, hvordan dette fungerer, med følgende eksempel:

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

Outputtet i dette tilfælde er:

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

### Superklasse/underklasse

Selvom objekter i underklasser også tilhører underklassens tilsvarende overklasser, fungerer det ikke omvendt. Følgende eksempel hjælper med at illustrere dette aspekt af klassehierarkiet:

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

Outputtet i dette tilfælde er:

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

### Fejlmeddelelse for inkompatible typer

Hvis der ikke er nogen forbindelse mellem et objekt og en klasse, vises en fejlmeddelelse. For at illustrere dette opretter vi en ny klasse kaldet ‘Dog’, som tilhører superklassen Animal, men som ikke har nogen forbindelse til Cat.

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

I denne situation modtager vi en fejlmeddelelse, der fortæller os, at der ikke er nogen forbindelse mellem klasserne Cat og Dog. Meddelelsen ser sådan ud:

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

Tip I vores digitale guide finder du flere spændende tutorials og informative artikler om Java. Du kan finde en sammenligning af [Java og JavaScript](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-vs-javascript/) samt en sammenligning af [Java og Python](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/python-vs-java/). Du kan også læse mere om [Java-bitvise operatorer](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-bitvise-operatorer/).


This is a markdown version of: [https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-operatoren-instanceof/](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-operatoren-instanceof/) for AI/LLM consumption.