Java instanceof Keyword with Examples
This article will look at the keyword ” instance of” in the Java programming language. We will begin by examining what it is used for and why we need it. In the end, we will look at the different examples of the “instanceof” keyword with the help of programs to understand its applications better.
To grasp the concept more quickly and master it sooner, I suggest that you practice each code in the article, make some modifications, and experiment with the code to cover different scenarios. This will help you understand the concept better and be able to apply it in different situations.
What is the “instanceof” keyword in Java?
In Java, the keyword “instanceof” determines whether a reference variable refers to an object of a particular type. This keyword is also known as the comparison operator because it compares the kind of an object to the type of an instance.
The instanceof keyword is used to check whether the given variable contains an object instance. It is also used for downcasting and checking if typecasting is valid. We will look at examples of these cases in the succeeding sections.
However, before we proceed further, let us look at a program that uses the instanceof keyword.
class FirstCode
{
public static void main(String[] args)
{
FirstCode FC = new FirstCode();
System.out.println(FC instanceof FirstCode);
}
}
Output:
True
In the code shown above, the output is true, as the object “FC” is indeed an object from the class “FirstCode”.
Examples of codes using the ‘instanceof’ keyword
Now that we know the basic functioning of the instanceof keyword, let us look at different scenarios of using the instanceof keyword.
1. Using instanceof while implementing Inheritance
class Parent {}
class Child extends Parent {}
class FirstCode
{
public static void main(String[] args)
{
Child ChildObject = new Child();
if (ChildObject instanceof Child)
System.out.println("Instance of Child class");
else
System.out.println("Not an instance of Child class");
if (ChildObject instanceof Parent)
System.out.println("ChildObject is an instance of Parent class");
else
System.out.println("Not an instance of Parent class");
if (ChildObject instanceof Object)
System.out.println("ChildObject is an instance of Object");
else
System.out.println("ChildObject is not an instance of Object");
}
}
Output:
Instance of Child class
Instance of Parent class
ChildObject is an instance of Object
In the above program, since the class “child” has been inherited from “parent” and the object has been created from the class “child”, the object ‘ChildObject’ is the instance of the child class, parent class as well as object.
2. Using instanceof keyword while returning false or null
class FirstCode {}
class Main
{
public static void main(String[] args)
{
FirstCode FC = null;
if (FC instanceof FirstCode)
System.out.println("Instance of the class FirstCode");
else
System.out.println("Not an instance of the class FirstCode");
}
}
Output:
Not an instance of the class FirstCode
In the program shown above, since we are not constructing an object (since object instantiation has been assigned to null), the object “FC” is not an instance of the class “FirstCode.”
3. Using ‘Instaceof’ to show that parent object is not instance of child class
class ParentClass {}
class ChildClass extends ParentClass {}
class FirstCode
{
public static void main(String[] args)
{
ParentClass ParentObject = new ParentClass();
if (ParentObject instanceof ChildClass)
System.out.println("Instance of the Child class");
else
System.out.println("Not an instance of the Child class");
}
}
Output:
Not an instance of the Child class
In the above program, since the object “ParentObject” was created from the parent class, and since the child class was inherited from the parent class, ‘parentObject’ is not an instance of the child class.
However, if we create an object from the child class, that object will be an instance of both the parent and child classes. The following example shows this.
4. Parent class referencing to a child class
class ParentClass {}
class ChildClass extends ParentClass {}
class FirstCode
{
public static void main(String[] args)
{
ParentClass ChildObject = new ChildClass();
if (ChildObject instanceof ChildClass)
System.out.println("Instance of Child class");
else
System.out.println("Not an instance of Child class");
}
}
Output:
Instance of Child class
In the above program, while instantiating the object, the parent class references the child class, hence the child object is an instance of the child class.
5. Using instanceof keyword while implementing interfaces
interface Parent {}
class Child implements Parent {}
class FirstCode
{
public static void main(String[] args)
{
Child obj = new Child();
System.out.println(obj instanceof Parent);
}
}
Output:
True
Similar to Inheritance, instead of using classes, if we use interfaces, the instanceof keyword still works the same way as with classes. In this example, Since the interface ‘child’ is inherited from the interface “parent”, the object created from the child is thus an instance of the parent interface.
6. Downcasting while using the instanceof keyword
Before we get into an example, let’s define downcasting. Downcasting occurs when a variable of a subclass type references an object of the parent class. If we attempt to implement this directly, the compiler will return a compilation error. If we attempt to accomplish this by typecasting, a ClassCastException will be thrown at runtime. However, if we use the instanceof operator, downcasting is possible.
Here is an example of downcasting:
class Animal { void eat() {System.out.println("Eating");}}
class Dog extends Animal {void bark() {System.out.println("Woof!");}}
public class FirstCode
{
public static void main(String[] args)
{
Animal animal = new Dog();
if (animal instanceof Dog)
{
Dog dog = (Dog) animal;
dog.bark();
}
}
}
Output:
Woof!
In this example, we create an Animal object and then downcast it to a Dog object. We can then call the Dog’s bark() method as it is an instanceof the Dog class.
We can also perform downcasting without the help of the instanceof keyword. Here is an example:
class Animal {}
class Dog extends Animal
{
static void method(Animal a)
{
Dog d=(Dog)a;
System.out.println("Downcasting performed");
}
}
class FirstCode
{
public static void main (String [] args)
{
Animal a = new Dog();
Dog.method(a);
}
}
Output:
Downcasting performed
7. Typefiltering in Stream API using instanceof keyword
Java 8 introduced a remarkable feature known as the Stream API, providing a powerful tool for transforming collections from one type to another using the map() method.
In situations where type conversion involves typecasting, validating the types before executing the typecasting process is imperative to prevent potential ClassCastException errors. Let us consider the code snippet shown below to understand better:
Stream<Round> roundStream = Stream.of(new Ring(), new Ring(), new Circle());
The roundStream object in the code snippet shown above comprises two Ring objects and one Circle instance. If we proceed to convert the roundStream to a list of Ring objects without validating the types, a ClassCastException will be triggered, given that a Circle is not inherently a Ring.
Conclusion
You have now learned about the instance of keywords present in Java as we have gone through various topics, such as what it is used for and why we need it. In the end, we looked at the different examples of the “instanceof” keyword with the help of programs to understand its applications better.