instanceof and Downcasting

Upcasting (treating a subclass object as its superclass or interface type) happens automatically and safely in Java. Downcasting — converting a superclass or interface reference back to a more specific subclass type — is not automatic, requires an explicit cast, and is only safe when the object being cast is genuinely an instance of that target type at runtime.

Why it matters

When code holds a general reference but needs something only a specific subtype offers, it has to downcast, and a wrong cast fails at runtime with ClassCastException. instanceof is the check that makes the cast safe, and modern Java combines the check and the cast into one step.

Why Downcasting Needs a Check

A reference variable's declared type limits what the compiler lets you call on it, but the actual object it points to at runtime might be any subclass. Casting a reference down to a more specific type without verifying the object's real type first risks a ClassCastException at runtime if the object is not actually of that type.

Using instanceof for Safe Downcasting

The instanceof operator checks whether an object is an instance of a given type (or a subtype of it) before you attempt the cast, returning a boolean. The traditional pattern is to check with instanceof first, then cast only if the check passes, avoiding an unguarded downcast that could throw.

Pattern Matching for instanceof (Modern Java)

Since Java 16, pattern matching for instanceof lets you combine the check and the cast in one expression: if (obj instanceof Dog dog) both tests the type and binds a new, already-cast variable (dog) usable inside that branch, eliminating the separate explicit cast statement and the boilerplate of the older two-step pattern.

Example

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

class Dog extends Animal {
    void fetch() {
        System.out.println("Dog is fetching the ball");
    }
}

public class InstanceofDemo {
    public static void main(String[] args) {
        Animal a = new Dog(); // upcasting, always safe

        // Traditional check-then-cast pattern
        if (a instanceof Dog) {
            Dog d = (Dog) a;
            d.fetch();
        }

        // Modern pattern matching for instanceof (Java 16+)
        if (a instanceof Dog dog) {
            dog.fetch();
        }

        Animal generic = new Animal();
        if (!(generic instanceof Dog)) {
            System.out.println("generic is not a Dog, downcast skipped safely");
        }
    }
}

Dog is fetching the ball
Dog is fetching the ball
generic is not a Dog, downcast skipped safely

Exercise

Write describe(Object value) using pattern matching for instanceof. A String returns text of length N, an Integer returns number followed by double its value, and anything else returns unknown. This needs Java 16 or newer.

Expected output: text of length 5, number 42, unknown

public class Describe {

    static String describe(Object value) {
        // TODO: use "value instanceof String text" and "value instanceof Integer number"
        return "unknown";
    }

    public static void main(String[] args) {
        System.out.println(describe("hello"));
        System.out.println(describe(21));
        System.out.println(describe(3.5));
    }
}

public class Describe {

    static String describe(Object value) {
        if (value instanceof String text) {
            return "text of length " + text.length();
        }
        if (value instanceof Integer number) {
            return "number " + (number * 2);
        }
        return "unknown";
    }

    public static void main(String[] args) {
        System.out.println(describe("hello")); // text of length 5
        System.out.println(describe(21));      // number 42
        System.out.println(describe(3.5));     // unknown
    }
}

Quick quiz

Interview questions