Wie man prüft, ob ein Objekt in Java einen bestimmten Typ hat

Einführung

In diesem Lab werden Sie lernen, wie Sie in Java überprüfen können, ob ein Objekt einen bestimmten Typ hat, indem Sie den instanceof-Operator verwenden. Sie beginnen damit, die grundlegende Verwendung von instanceof mit verschiedenen Klassen, einschließlich Vererbung, zu verstehen.

Anschließend werden Sie den instanceof-Operator mit verschiedenen Klassentypen testen und untersuchen, wie er sich mit Unterklassen und Oberklassen verhält. Schließlich werden Sie lernen, wie Sie Null-Objekte beim Verwenden von instanceof behandeln, um potenzielle Fehler zu vermeiden.

Verwenden des instanceof-Operators

In diesem Schritt werden Sie über den instanceof-Operator in Java lernen. Der instanceof-Operator wird verwendet, um zu testen, ob ein Objekt eine Instanz einer bestimmten Klasse ist oder ein bestimmtes Interface implementiert. Es ist ein nützliches Werkzeug zum Überprüfen des Typs eines Objekts zur Laufzeit.

Lassen Sie uns ein einfaches Java-Programm erstellen, um zu demonstrieren, wie der instanceof-Operator funktioniert.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor, wenn sie noch nicht geöffnet ist.

Ersetzen Sie den gesamten Inhalt der Datei durch folgenden Code:

class Animal {
    public void makeSound() {
        System.out.println("Generic animal sound");
    }
}

class Dog extends Animal {
    public void makeSound() {
        System.out.println("Woof!");
    }
}

class Cat extends Animal {
    public void makeSound() {
        System.out.println("Meow!");
    }
}

public class HelloJava {
    public static void main(String[] args) {
        Animal myAnimal = new Dog();

        if (myAnimal instanceof Dog) {
            System.out.println("myAnimal is an instance of Dog");
        }

        if (myAnimal instanceof Cat) {
            System.out.println("myAnimal is an instance of Cat");
        }

        if (myAnimal instanceof Animal) {
            System.out.println("myAnimal is an instance of Animal");
        }
    }
}

In diesem Code:

Wir definieren eine Basisklasse Animal und zwei Unterklassen Dog und Cat.
In der main-Methode erstellen wir eine Animal-Variable myAnimal und weisen ihr ein Dog-Objekt zu.
Wir verwenden dann den instanceof-Operator, um zu überprüfen, ob myAnimal eine Instanz von Dog, Cat und Animal ist.

Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das Programm mit dem javac-Befehl im Terminal:
```
javac HelloJava.java
```
Führen Sie das kompilierte Programm mit dem java-Befehl aus:
```
java HelloJava
```
Sie sollten eine Ausgabe sehen, die anzeigt, welche instanceof-Prüfungen true zurückgegeben haben.
```
myAnimal is an instance of Dog
myAnimal is an instance of Animal
```
Wie Sie sehen können, ist myAnimal eine Instanz von Dog (weil wir ein Dog-Objekt erstellt haben) und auch eine Instanz von Animal (weil Dog eine Unterklasse von Animal ist). Es ist keine Instanz von Cat.

Testen mit verschiedenen Klassen

Im vorherigen Schritt haben Sie gesehen, wie instanceof mit einer Unterklasse und ihrer Oberklasse funktioniert. Jetzt wollen wir untersuchen, wie es sich verhält, wenn man gegen verschiedene, nicht verwandte Klassen testet.

Wir werden die vorhandene Datei HelloJava.java ändern, um eine weitere Klasse hinzuzufügen und den instanceof-Operator mit Objekten verschiedener Typen zu testen.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.
Fügen Sie der Datei eine neue Klasse namens Car hinzu. Sie können diese Klassendefinition vor oder nach den Klassen Animal, Dog und Cat hinzufügen, aber außerhalb der Klasse HelloJava.
```
class Car {
    public void drive() {
        System.out.println("Driving a car");
    }
}
```

Jetzt ändern wir die main-Methode innerhalb der Klasse HelloJava, um ein Car-Objekt zu erstellen und den instanceof-Operator zu testen. Aktualisieren Sie die main-Methode so, dass sie wie folgt aussieht:

public class HelloJava {
    public static void main(String[] args) {
        Animal myAnimal = new Dog();
        Car myCar = new Car();

        if (myAnimal instanceof Dog) {
            System.out.println("myAnimal is an instance of Dog");
        }

        if (myAnimal instanceof Cat) {
            System.out.println("myAnimal is an instance of Cat");
        }

        if (myAnimal instanceof Animal) {
            System.out.println("myAnimal is an instance of Animal");
        }

        System.out.println("--- Testing Car object ---");

        if (myCar instanceof Car) {
            System.out.println("myCar is an instance of Car");
        }

        if (myCar instanceof Animal) {
            System.out.println("myCar is an instance of Animal");
        }
    }
}

Wir haben ein neues Car-Objekt myCar hinzugefügt und instanceof-Prüfungen für es gegen Car und Animal eingefügt.

Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das geänderte Programm:
```
javac HelloJava.java
```
Führen Sie das Programm aus:
```
java HelloJava
```
Beobachten Sie die Ausgabe. Sie sollten die Ergebnisse aus dem vorherigen Schritt sehen, gefolgt von den Ergebnissen der neuen Prüfungen für das Car-Objekt.
```
myAnimal is an instance of Dog
myAnimal is an instance of Animal
--- Testing Car object ---
myCar is an instance of Car
```
Diese Ausgabe bestätigt, dass myCar eine Instanz von Car ist, aber keine Instanz von Animal, da Car nicht von Animal erbt. Der instanceof-Operator erkennt korrekt die Typbeziehung (oder deren Fehlen) zwischen Objekten und Klassen.

Umgang mit Null-Objekten

In diesem letzten Schritt werden wir untersuchen, wie sich der instanceof-Operator beim Umgang mit null-Objekten verhält. Das Verständnis davon ist wichtig, um unerwartete Fehler in Ihren Programmen zu vermeiden.

Eine null-Referenz in Java bedeutet, dass eine Variable auf kein Objekt verweist. Wenn Sie den instanceof-Operator mit einer null-Referenz verwenden, gibt er immer false zurück. Dies ist ein integriertes Sicherheitsmerkmal des Operators.

Lassen Sie uns die Datei HelloJava.java ein letztes Mal ändern, um ein null-Objekt einzubeziehen und den instanceof-Operator zu testen.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.

Ändern Sie die main-Methode innerhalb der Klasse HelloJava, um eine null-Referenz auf ein Animal-Objekt einzubeziehen und diese zu testen. Aktualisieren Sie die main-Methode so, dass sie wie folgt aussieht:

class Animal {
    public void makeSound() {
        System.out.println("Generic animal sound");
    }
}

class Dog extends Animal {
    public void makeSound() {
        System.out.println("Woof!");
    }
}

class Cat extends Animal {
    public void makeSound() {
        System.out.println("Meow!");
    }
}

class Car {
    public void drive() {
        System.out.println("Driving a car");
    }
}

public class HelloJava {
    public static void main(String[] args) {
        Animal myAnimal = new Dog();
        Car myCar = new Car();
        Animal nullAnimal = null; // Declare a null Animal reference

        if (myAnimal instanceof Dog) {
            System.out.println("myAnimal is an instance of Dog");
        }

        if (myAnimal instanceof Cat) {
            System.out.println("myAnimal is an instance of Cat");
        }

        if (myAnimal instanceof Animal) {
            System.out.println("myAnimal is an instance of Animal");
        }

        System.out.println("--- Testing Car object ---");

        if (myCar instanceof Car) {
            System.out.println("myCar is an instance of Car");
        }

        if (myCar instanceof Animal) {
            System.out.println("myCar is an instance of Animal");
        }

        System.out.println("--- Testing null object ---");

        if (nullAnimal instanceof Animal) {
            System.out.println("nullAnimal is an instance of Animal");
        }

        if (nullAnimal instanceof Dog) {
            System.out.println("nullAnimal is an instance of Dog");
        }
    }
}

Wir haben eine neue Animal-Variable nullAnimal hinzugefügt und sie auf null initialisiert. Anschließend führen wir instanceof-Prüfungen an ihr durch.

Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das Programm:
```
javac HelloJava.java
```
Führen Sie das Programm aus:
```
java HelloJava
```
Beobachten Sie die Ausgabe. Sie sollten die Ergebnisse aus den vorherigen Schritten sehen, gefolgt von den Ergebnissen der Prüfungen für nullAnimal.
```
myAnimal is an instance of Dog
myAnimal is an instance of Animal
--- Testing Car object ---
myCar is an instance of Car
--- Testing null object ---
```
Beachten Sie, dass die Zeilen innerhalb der if-Blöcke für nullAnimal nicht ausgegeben werden. Dies liegt daran, dass sowohl nullAnimal instanceof Animal als auch nullAnimal instanceof Dog zu false auswerten. Dies zeigt, dass der instanceof-Operator null-Referenzen korrekt behandelt, indem er false zurückgibt.

Das Verständnis, wie instanceof mit null funktioniert, ist entscheidend für das Schreiben von robustem Java-Code, der NullPointerException-Fehler vermeidet.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie in Java überprüfen können, ob ein Objekt einen bestimmten Typ hat, indem Sie den instanceof-Operator verwenden. Sie haben das Verwenden von instanceof mit verschiedenen Klassen geübt, einschließlich einer Basisklasse und ihrer Unterklassen, um den Laufzeittyp eines Objekts zu bestimmen. Sie haben auch untersucht, wie sich instanceof verhält, wenn Sie gegen die tatsächliche Klasse des Objekts, seine Oberklasse und nicht verwandte Klassen prüfen.