Use of "instanceof" in Java

Question

What is the 'instanceof' operator used for?

I learned that Java has the instanceof operator. Can you elaborate where it is used and what are its advantages?

Solution 1

Basically, you check if an object is an instance of a specific class. You normally use it, when you have a reference or parameter to an object that is of a super class or interface type and need to know whether the actual object has some other type (normally more concrete).

Example:

public void doSomething(Number param) {
  if( param instanceof Double) {
    System.out.println("param is a Double");
  }
  else if( param instanceof Integer) {
    System.out.println("param is an Integer");
  }

  if( param instanceof Comparable) {
    //subclasses of Number like Double etc. implement Comparable
    //other subclasses might not -> you could pass Number instances that don't implement that interface
    System.out.println("param is comparable"); 
  }
}

Note that if you have to use that operator very often it is generally a hint that your design has some flaws. So in a well designed application you should have to use that operator as little as possible (of course there are exceptions to that general rule).

Solution 2

instanceof is used to check if an object is an instance of a class, an instance of a subclass, or an instance of a class that implements a particular interface.

Read more from the Oracle language definition here.

Solution 3

instanceof can be used to determine the actual type of an object:

class A { }  
class C extends A { } 
class D extends A { } 

public static void testInstance(){
    A c = new C();
    A d = new D();
    Assert.assertTrue(c instanceof A && d instanceof A);
    Assert.assertTrue(c instanceof C && d instanceof D);
    Assert.assertFalse(c instanceof D);
    Assert.assertFalse(d instanceof C);
}

Solution 4

instanceof is a keyword that can be used to test if an object is of a specified type.

Example :

public class MainClass {
    public static void main(String[] a) {

    String s = "Hello";
    int i = 0;
    String g;
    if (s instanceof java.lang.String) {
       // This is going to be printed
       System.out.println("s is a String");
    }
    if (i instanceof Integer) {
       // This is going to be printed as autoboxing will happen (int -> Integer)
       System.out.println("i is an Integer");
    }
    if (g instanceof java.lang.String) {
       // This case is not going to happen because g is not initialized and
       // therefore is null and instanceof returns false for null. 
       System.out.println("g is a String");
    } 
} 

Here is my source.

View more solutions

Comments

[Bringer128]

Have you had a look at this?

[Scorpion]

This SO link should give you a lot of idea: stackoverflow.com/questions/496928/…

[Vishy]

If I google your question I get 11.7 million results. Is there something you would like to know which has not already been discussed at length?

[Edward Newell]

Dup maybe, but questions like this make SO a great resource across all skill levels. I am glad this was the top result when I goog'd.

[Jason]

Here's a good article on the use of this: javatpoint.com/downcasting-with-instanceof-operator

[Mehdi Haghgoo]

Not saying this is not a good question. But, I am very amazed how such highly discussed-all-over-the-web questions got so many upvotes and I'm pretty sure if someone asks such a question today, they will get lots of downvotes right away. So, I'd be glad if someone give some elaboration in case there is any difference.

[etech]

Is the Integer.class format actually legal? When I attempt to use it in your example, in Eclipse, I get Syntax error on token "class", Identifier expected. However, switching it to simply Integer works fine.

[Thomas]

@etech you're right, I'll fix that. It's been a while since I wrote that answer ;)

[Sudhakar]

When using the instanceof operator, keep in mind that null is not an instance of anything.

[Sam]

A common place to find this method is in .equals() methods. it's common for intelliJ to generate equals methods that use instanceof

[Jace J McPherson]

There are definitely cases when you should use instanceof in your design, especially with developing an API and throwing misuse exceptions

[Klaider]

Loved the answer, but I'm creating a lexer and I need to use instanceof to determine the type of tokens (e.g. Identifier, Literal, etc..., extending from Token). If I was not going to use instanceof, then I'd have an unique Token class and would have to create various unnecessary different type of fields to hold the value of the actual token.

[Reishin]

miss-leading answer, which taking one situation and making judge on whole keyword =\

[Hummeling Engineering BV]

Why don't you use if? Now the second and third conditions aren't evaluated since the first is true.

[Barth]

@HummelingEngineeringBV you are actually right, I reacted a bit too fast to the comment of Tim . We do want to evalute each of these conditions. Thank you, edited.

[Marc van Dongen]

@Hydro You could also introduce a dedicated \texttt{enum} class for your kinds of tokens.

[Aleksandr Erokhin]

Just want to add why usage of this operator indicates design flaws. The abstraction that needs to be cast to the concrete type doesn't provide enough information. It's either just some bad abstraction or abstraction that is used in a wrong domain. You can check detailed explanation with an example here: medium.com/@aerokhin/… .