Java instanceof Keyword
Usage and Examples

instanceof Keyword in Java

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.

Syntax

object instanceof ClassName

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

Why Use instanceof?

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

Basic Example

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

Explanation

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.

instanceof with Null Reference

If the reference is null, instanceof always returns false.

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

false

Using instanceof Before Casting

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

Polymorphic Behavior and instanceof

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

instanceof with Interfaces

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 and Pattern Matching with instanceof

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.

Best Practices

• 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.