The instanceof Operator

Part of the Object Oriented Programming section of Coddy's Java journey — lesson 31 of 87.

The previous lesson showed that downcasting can fail with a ClassCastException if the object isn't actually the type you're casting to. The instanceof operator solves this by letting you check an object's type before casting.

The syntax is straightforward: object instanceof ClassName returns true if the object is an instance of that class (or any of its subclasses):

Animal animal = new Dog();

if (animal instanceof Dog) {
    Dog dog = (Dog) animal;
    dog.bark();  // Safe to call Dog-specific methods
}

This check prevents runtime errors by ensuring the cast will succeed. The operator also returns true for parent types in the hierarchy:

Dog dog = new Dog();
System.out.println(dog instanceof Dog);     // true
System.out.println(dog instanceof Animal);  // true
System.out.println(dog instanceof Object);  // true

Since Java 16, you can combine the check and cast in one step using pattern matching:

if (animal instanceof Dog dog) {
    dog.bark();  // 'dog' is already cast and ready to use
}

This cleaner syntax eliminates the separate cast line. Note that instanceof returns false when tested against null, so you don't need a separate null check.

Challenge

Easy

Let's build a vehicle inspection system that uses the instanceof operator to safely identify and handle different vehicle types. You'll create a hierarchy of vehicles and write code that checks each vehicle's actual type before accessing its specialized features.

You'll organize your code across four files:

Vehicle.java: Create the base class that all vehicles share. Every vehicle has a model field (String). Include a constructor to initialize it, a getter method getModel(), and a method inspect() that prints: Inspecting vehicle: [model]
Car.java: Create a class that extends Vehicle. Cars have an additional numDoors field (int). Use super for the parent initialization. Add a method checkDoors() that prints: [model] has [numDoors] doors
Motorcycle.java: Create another class that extends Vehicle. Motorcycles have a hasSidecar field (boolean). Add a method checkSidecar() that prints either [model] has a sidecar or [model] has no sidecar depending on the boolean value.
Main.java: Here's where instanceof becomes essential! You'll receive four inputs: a car model, number of doors, a motorcycle model, and whether it has a sidecar (true/false).
Create an array of Vehicle references containing a Car and a Motorcycle. Then loop through the array and for each vehicle:
- Call the base inspect() method
- Use instanceof to check if it's a Car - if so, safely downcast and call checkDoors()
- Use instanceof to check if it's a Motorcycle - if so, safely downcast and call checkSidecar()

You will receive four inputs: the car model (String), number of doors (int), motorcycle model (String), and has sidecar (boolean).

Your output should show four lines - for each vehicle, you'll see its inspection message followed by its type-specific check. The instanceof operator ensures you only call Car methods on actual Cars and Motorcycle methods on actual Motorcycles, preventing any ClassCastException!

Try it yourself

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Read inputs
        String carModel = scanner.nextLine();
        int numDoors = Integer.parseInt(scanner.nextLine());
        String motorcycleModel = scanner.nextLine();
        boolean hasSidecar = Boolean.parseBoolean(scanner.nextLine());
        
        // TODO: Create a Car object with carModel and numDoors
        
        // TODO: Create a Motorcycle object with motorcycleModel and hasSidecar
        
        // TODO: Create an array of Vehicle references containing the Car and Motorcycle
        
        // TODO: Loop through the array and for each vehicle:
        // 1. Call the inspect() method
        // 2. Use instanceof to check if it's a Car, then downcast and call checkDoors()
        // 3. Use instanceof to check if it's a Motorcycle, then downcast and call checkSidecar()
    }
}