instanceof checks before a risky cast

Understanding instanceof checks before a risky cast

A cast like `(Circle) shape` is a command: it tells the JVM to treat the object as a Circle and to throw ClassCastException if it is not one. instanceof is the matching question: it inspects the object the reference actually points to and returns true when that object's class is the named type or any subtype of it. Asking first and casting second means the risky line only runs on the path where the answer was yes. The declared type of the reference matters only at compile time, where it decides whether the question is legal to ask; the answer comes from the object itself at runtime.

Two details make the guard airtight. First, `null instanceof Circle` is false, because there is no object to inspect, so one instanceof covers both wrong type and nothing here. Second, since Java 16 you can write `if (shape instanceof Circle c)`, which runs the test and, on success, binds the already-cast value to c. The pattern variable is in scope exactly where the compiler can prove the test succeeded, which is why the right side of `&&` can use it, why `||` does not compile, and why `if (!(o instanceof String s)) return;` leaves s usable for the rest of the method.

Because instanceof is true for a type and everything below it, a chain of checks has to run most specific first: if Puppy extends Dog and you test Dog first, the Puppy branch is dead in practice and no compiler warning points that out. That ordering rule is also a design hint. A long chain over classes you wrote usually means the behaviour belongs in an overridden method on the supertype, while the check earns its place when you cannot add a method: an Object parameter in equals, values coming out of a parser, types from a library you do not own.

import java.util.ArrayList;
import java.util.List;

class Shape { }

class Circle extends Shape {
    private final double radius;
    Circle(double radius) { this.radius = radius; }
    double radius() { return radius; }
}

class Square extends Shape {
    private final double side;
    Square(double side) { this.side = side; }
    double side() { return side; }
}

class Triangle extends Shape { }

public class Main {
    static String describe(Shape s) {
        if (s instanceof Circle) {
            Circle c = (Circle) s;              // safe: the test above already answered yes
            return "circle, radius " + c.radius();
        }
        if (s instanceof Square sq) {           // test and bind in one step
            return "square, side " + sq.side();
        }
        return "no rule for " + (s == null ? "null" : s.getClass().getSimpleName());
    }

    public static void main(String[] args) {
        List<Shape> shapes = new ArrayList<>();
        shapes.add(new Circle(2));
        shapes.add(new Square(3));
        shapes.add(new Triangle());
        shapes.add(null);
        for (Shape s : shapes) {
            System.out.println(describe(s));
        }
    }
}

Worked examples

public class Main {
    public static void main(String[] args) {
        Object o = null;
        System.out.println(o instanceof String);
        if (o instanceof String s) {
            System.out.println("length " + s.length());
        } else {
            System.out.println("no string here, no cast attempted");
        }

        Object p = "hello";
        System.out.println(p instanceof String);
        System.out.println(p instanceof Integer);
        System.out.println(((String) p).length());
    }
}

class Animal { }
class Dog extends Animal { }
class Puppy extends Dog { }

public class Main {
    static String wrongOrder(Animal a) {
        if (a instanceof Dog) return "dog";
        if (a instanceof Puppy) return "puppy";
        return "animal";
    }

    static String rightOrder(Animal a) {
        if (a instanceof Puppy) return "puppy";
        if (a instanceof Dog) return "dog";
        return "animal";
    }

    public static void main(String[] args) {
        Animal a = new Puppy();
        System.out.println(wrongOrder(a));
        System.out.println(rightOrder(a));
        System.out.println(a instanceof Dog);
        System.out.println(a instanceof Animal);
    }
}

public class Main {
    static int lengthOrMinusOne(Object o) {
        if (!(o instanceof String s)) {
            return -1;
        }
        return s.length();
    }

    static boolean sameLength(Object a, Object b) {
        return a instanceof String s && b instanceof String t && s.length() == t.length();
    }

    public static void main(String[] args) {
        System.out.println(lengthOrMinusOne("stack"));
        System.out.println(lengthOrMinusOne(42));
        System.out.println(sameLength("abc", "xyz"));
        System.out.println(sameLength("abc", 7));
    }
}

Important notes

Common mistakes

Try it yourself