Java instanceof Operator Explained — How Type Checking Really Works

// AnimalTypeCheck.java
// Demonstrates why instanceof exists and what it protects you from.

public class AnimalTypeCheck {

    // A simple Animal base class — every animal has a name
    static class Animal {
        String name;
        Animal(String name) {
            this.name = name;
        }
    }

    // Dog extends Animal and adds a breed-specific behaviour
    static class Dog extends Animal {
        String breed;
        Dog(String name, String breed) {
            super(name);
            this.breed = breed;
        }
        void fetch() {
            System.out.println(name + " fetches the ball! Breed: " + breed);
        }
    }

    // Cat extends Animal and adds its own behaviour
    static class Cat extends Animal {
        Cat(String name) {
            super(name);
        }
        void purr() {
            System.out.println(name + " purrs contentedly.");
        }
    }

    public static void main(String[] args) {

        // We declare the variable as Animal (the parent type).
        // At runtime, it holds a Dog object.
        Animal firstAnimal = new Dog("Rex", "Labrador");

        // At runtime, this one holds a Cat object.
        Animal secondAnimal = new Cat("Whiskers");

        // Safe type check before casting — this is the core use of instanceof
        if (firstAnimal instanceof Dog) {
            // We KNOW it's a Dog here, so the cast is 100% safe
            Dog myDog = (Dog) firstAnimal;
            myDog.fetch(); // Can now call Dog-specific method
        }

        // Checking secondAnimal — it's a Cat, not a Dog
        if (secondAnimal instanceof Dog) {
            // This block will NOT execute — instanceof returned false
            System.out.println("This won't print.");
        } else {
            System.out.println(secondAnimal.name + " is NOT a Dog — skipping Dog logic.");
        }

        // Also works with the actual type
        if (secondAnimal instanceof Cat) {
            Cat myCat = (Cat) secondAnimal;
            myCat.purr(); // Cat-specific method, safely called
        }
    }
}

// InheritanceChainCheck.java
// Shows how instanceof checks the ENTIRE inheritance tree, not just the exact type.

public class InheritanceChainCheck {

    interface Swimmable {
        void swim();
    }

    static class Animal {}

    static class Dog extends Animal implements Swimmable {
        @Override
        public void swim() {
            System.out.println("Dog is swimming!");
        }
    }

    public static void main(String[] args) {

        Dog labrador = new Dog();

        // Check against its own class — obvious true
        System.out.println("labrador instanceof Dog: "
            + (labrador instanceof Dog));         // true

        // Check against its parent class — also true (Dog IS-A Animal)
        System.out.println("labrador instanceof Animal: "
            + (labrador instanceof Animal));      // true

        // Check against the interface it implements — also true
        System.out.println("labrador instanceof Swimmable: "
            + (labrador instanceof Swimmable));   // true

        // Check against an unrelated class — false
        System.out.println("labrador instanceof String: "
            + (labrador instanceof String));      // Won't even compile!
        // NOTE: Java catches impossible checks at compile time — if two types
        // have no relationship at all, the compiler rejects it immediately.

        // The special null rule — null is never an instance of anything
        Animal noAnimal = null;
        System.out.println("null instanceof Animal: "
            + (noAnimal instanceof Animal));      // false — no NullPointerException!

        // ⚠️ Wrong order: checking parent BEFORE child — Dog branch unreachable
        Animal unknownAnimal = new Dog();
        System.out.println("\n--- Wrong order (parent checked first) ---");
        if (unknownAnimal instanceof Animal) {
            System.out.println("Caught by Animal — never reaches Dog check!");
        } else if (unknownAnimal instanceof Dog) {
            System.out.println("This will NEVER print.");
        }

        // ✅ Correct order: most specific type first
        System.out.println("\n--- Correct order (child checked first) ---");
        if (unknownAnimal instanceof Dog) {
            System.out.println("Correctly identified as Dog first.");
        } else if (unknownAnimal instanceof Animal) {
            System.out.println("Generic Animal — not a Dog.");
        }
    }
}

// PatternMatchingDemo.java
// Compares OLD instanceof (check + cast) vs NEW pattern matching (Java 16+).
// Run with: javac PatternMatchingDemo.java && java PatternMatchingDemo

public class PatternMatchingDemo {

    sealed interface Shape permits Circle, Rectangle, Triangle {}

    record Circle(double radius) implements Shape {}
    record Rectangle(double width, double height) implements Shape {}
    record Triangle(double base, double height) implements Shape {}

    // --- OLD WAY (before Java 16) --- verbose and repetitive
    static double calculateAreaOldWay(Shape shape) {
        if (shape instanceof Circle) {
            Circle circle = (Circle) shape; // Redundant cast after the check
            return Math.PI * circle.radius() * circle.radius();
        } else if (shape instanceof Rectangle) {
            Rectangle rectangle = (Rectangle) shape; // Same redundancy
            return rectangle.width() * rectangle.height();
        } else if (shape instanceof Triangle) {
            Triangle triangle = (Triangle) shape;
            return 0.5 * triangle.base() * triangle.height();
        }
        throw new IllegalArgumentException("Unknown shape: " + shape);
    }

    // --- NEW WAY (Java 16+) --- pattern matching, no manual cast needed
    static double calculateAreaNewWay(Shape shape) {
        // The variable 'circle' is declared AND assigned in one step.
        // It's only in scope inside this if-block — safe by design.
        if (shape instanceof Circle circle) {
            return Math.PI * circle.radius() * circle.radius();
        } else if (shape instanceof Rectangle rectangle) {
            return rectangle.width() * rectangle.height();
        } else if (shape instanceof Triangle triangle) {
            return 0.5 * triangle.base() * triangle.height();
        }
        throw new IllegalArgumentException("Unknown shape: " + shape);
    }

    public static void main(String[] args) {
        Shape[] shapes = {
            new Circle(5.0),
            new Rectangle(4.0, 6.0),
            new Triangle(3.0, 8.0)
        };

        System.out.println("=== Old Way ===");
        for (Shape shape : shapes) {
            System.out.printf("%s area = %.2f%n",
                shape.getClass().getSimpleName(),
                calculateAreaOldWay(shape));
        }

        System.out.println("\n=== New Way (Pattern Matching) ===");
        for (Shape shape : shapes) {
            System.out.printf("%s area = %.2f%n",
                shape.getClass().getSimpleName(),
                calculateAreaNewWay(shape));
        }

        // Bonus: pattern matching variable usable in the SAME condition
        Shape mystery = new Circle(7.0);
        // You can even add extra conditions with && in the same line
        if (mystery instanceof Circle bigCircle && bigCircle.radius() > 5) {
            System.out.println("\nBig circle detected! Radius: " + bigCircle.radius());
        }
    }
}

// InstanceofMistakes.java
// Three real mistakes beginners make with instanceof, shown side by side with fixes.

public class InstanceofMistakes {

    static class Vehicle {}
    static class Car extends Vehicle {
        void honk() { System.out.println("Beep beep!"); }
    }
    static class ElectricCar extends Car {
        void chargeBattery() { System.out.println("Charging battery..."); }
    }

    public static void main(String[] args) {

        Vehicle myVehicle = new ElectricCar(); // Declared as Vehicle, actually ElectricCar

        // ❌ MISTAKE 1: Wrong check order — parent before child
        System.out.println("--- MISTAKE 1: Wrong check order ---");
        if (myVehicle instanceof Car) {
            // ElectricCar IS-A Car, so this matches FIRST
            System.out.println("Matched Car — ElectricCar logic NEVER reached!");
        } else if (myVehicle instanceof ElectricCar) {
            System.out.println("This line is unreachable dead code.");
        }

        // ✅ FIX 1: Most specific type first
        System.out.println("--- FIX 1: Correct check order ---");
        if (myVehicle instanceof ElectricCar electricCar) {
            System.out.println("Correctly identified as ElectricCar!");
            electricCar.chargeBattery();
        } else if (myVehicle instanceof Car car) {
            System.out.println("It's a regular Car.");
            car.honk();
        }

        // ❌ MISTAKE 2: Thinking instanceof checks the DECLARED type
        System.out.println("\n--- MISTAKE 2: Declared type confusion ---");
        Vehicle anotherVehicle = new Car(); // Declared as Vehicle
        // Beginner thinks: "the variable says Vehicle, so instanceof Car is false"
        // WRONG. instanceof checks the OBJECT, not the variable declaration.
        System.out.println("anotherVehicle instanceof Car: "
            + (anotherVehicle instanceof Car)); // true — the object IS a Car
        System.out.println("anotherVehicle instanceof Vehicle: "
            + (anotherVehicle instanceof Vehicle)); // also true — Car IS-A Vehicle

        // ❌ MISTAKE 3: Using instanceof with null without knowing it's safe
        System.out.println("\n--- MISTAKE 3: null confusion ---");
        Vehicle nullVehicle = null;
        // Beginner worries: "will this throw NullPointerException?"
        // Answer: NO. instanceof always returns false for null. No exception.
        System.out.println("null instanceof Vehicle: "
            + (nullVehicle instanceof Vehicle)); // false — safe, no NPE
    }
}