Java instanceof and its applications

instanceof is a keyword that is used for checking if a reference variable is containing a given type of object reference or not.

Following is a Java program to show different behaviors of instanceof.

Output :

testObj is instance of Child
testObj is instance of Parent
testObj is instance of Object

instanceof returns false for null

// Java program to demonstrate that instanceof
// returns false for null

class Test { }

class Main
{
public static void main(String[] args)
{
Test tobj = null;

// A simple case
if (tobj instanceof Test)
System.out.println("obj is instance of Test");
else
System.out.println("obj is NOT instance of Test");
}
}
Output :

obj is NOT instance of Test
A parent object is not an instance of Child

// A Java program to show that a parent object is
// not an instance of Child

class Parent { }
class Child extends Parent { }

class Test
{
public static void main(String[] args)
{
Parent pobj = new Parent();
if (pobj instanceof Child)
System.out.println("pobj is instance of Child");
else
System.out.println("pobj is NOT instance of Child");
}
}
Output :

pobj is NOT instance of Child
A parent reference referring to a Child is an instance of Child

// A Java program to show that a parent reference
// referring to a Child is an instance of Child

class Parent { }
class Child extends Parent { }

class Test
{
public static void main(String[] args)
{
// Reference is Parent type but object is
// of child type.
Parent cobj = new Child();
if (cobj instanceof Child)
System.out.println("cobj is instance of Child");
else
System.out.println("cobj is NOT instance of Child");
}
}
Output :

cobj is an instance of Child

Application:

• We have seen here that a parent class data member is accessed when a reference of parent type refers to a child object. We can access child data member using type casting.
• Syntax: ((child_class_name) Parent_Reference_variable).func.name().
• When we do typecast, it is always a good idea to check if the typecasting is valid or not. instanceof helps us here.
• We can always first check for validity using instancef, then do typecasting.

// A Java program to demonstrate that non-method
// members are accessed according to reference
// type (Unlike methods which are accessed according
// to the referred object)

class Parent
{
int value = 1000;
}

class Child extends Parent
{
int value = 10;
}

// Driver class
class Test
{
public static void main(String[] args)
{
Parent cobj = new Child();
Parent par = cobj;

// Using instanceof to make sure that par
// is a valid reference before typecasting
if (par instanceof Child)
{
System.out.println("Value accessed through " +
"parent reference with typecasting is " +
((Child)par).value);
}
}
}
Output:

Value accessed through parent reference with typecasting is 10