instanceof Keyword Usage and Examples

Learn how to use the Java instanceof keyword with practical examples. Understand type checking in Java, its syntax, behavior with inheritance, and how to avoid ClassCastException using instanceof.

This reference explains instanceof Keyword Usage and Examples through its syntax, examples and boundaries. Use the linked course lessons when the surrounding Java concepts are unfamiliar.

The instanceof keyword in Java is used to test whether an object is an instance of a specific class or implements an interface. It's a type-checking operator that returns true or false.

This is particularly useful when you're dealing with inheritance or polymorphism and want to confirm an object's actual type before casting it.

object instanceof ClassName

This will return true if object is an instance of ClassName, otherwise false.

To safely cast an object, especially in inheritance hierarchies. Without checking the type, casting can throw a ClassCastException.

class Animal {}

class Dog extends Animal {}

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

        System.out.println(a instanceof Animal); // true
        System.out.println(a instanceof Dog);    // true
        System.out.println(a instanceof Object); // true
    }
}

true
true
true

Java · example discussed here

class Animal {}

class Dog extends Animal {}

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

        System.out.println(a instanceof Animal); // true
        System.out.println(a instanceof Dog);    // true
        System.out.println(a instanceof Object); // true
    }
}

Even though a is declared as Animal, the actual object is a Dog, which is a subclass of Animal. Hence, all three checks return true.

If the reference is null, instanceof always returns false.

Dog d = null;
System.out.println(d instanceof Dog); // false

false

Let's avoid a ClassCastException by checking the type before casting:

class Animal {}
class Cat extends Animal {}
class Dog extends Animal {}

public class Demo {
    public static void main(String[] args) {
        Animal a = new Cat();

        if (a instanceof Dog) {
            Dog d = (Dog) a;
        } else {
            System.out.println("a is not a Dog");
        }
    }
}

a is not a Dog

The keyword shines in polymorphic scenarios where a superclass reference points to subclass objects:

class Shape {}
class Circle extends Shape {}
class Rectangle extends Shape {}

public class ShapeTest {
    public static void main(String[] args) {
        Shape s1 = new Circle();
        Shape s2 = new Rectangle();

        System.out.println(s1 instanceof Circle);     // true
        System.out.println(s2 instanceof Rectangle);  // true
        System.out.println(s1 instanceof Rectangle);  // false
    }
}

true
true
false

You can also check if an object implements an interface using instanceof:

interface Drawable {}
class Image implements Drawable {}
class Text {}

public class InterfaceTest {
    public static void main(String[] args) {
        Object obj = new Image();

        System.out.println(obj instanceof Drawable); // true
        System.out.println(obj instanceof Text);     // false
    }
}

true
false

Java 16 introduced pattern matching with instanceof for cleaner syntax:

Object obj = "hello";

if (obj instanceof String str) {
    System.out.println(str.toUpperCase());
}

HELLO

This eliminates the need for a separate cast after checking type.

• Use instanceof only when necessary — often polymorphism can solve the problem more cleanly.
• Prefer interface checks when possible for flexibility.
• Don't use instanceof as a replacement for poor class design. If you find yourself using it frequently, consider if your design can be improved.

Check the example’s types, inputs and documented behavior before copying it into an application. Some APIs require external libraries, files or platform services; consult their setup notes.

Related explanations: Java Data Types - Primitive and Non-Primitive, Java Class - Blueprint of Objects, Exceptions in Java Introduction.

Supporting documentation: Official Java learning guide.