In Java, instanceof
keyword is a binary operator. It is used to check whether an object is an instance of a particular class or not.
The operator also checks whether an object is an instance of a class that implements an interface (will be discussed later in this tutorial).
The syntax of instanceof
operator is:
result = objectName instanceof className;
The left operand of the instanceof
operator is the object name and the right operand is the class name. The result will be true
if an object is an instance of a class and false
if it is not.
class Main {
public static void main (String[] args) {
String name = "Programiz";
Integer age = 22;
System.out.println("Is name an instance of String: "+ (name instanceof String));
System.out.println("Is age an instance of Integer: "+ (age instanceof Integer));
}
}
When we run the program, the output will be:
Is name an instance of String: true Is age an instance of Integer: true
In the above example, we have created an object name of the String
type and another object age of the Integer
type. We then used the instanceof
operator to check whether name is of the String
type and age is of the Integer
type.
In the case of inheritance, the instanceof
operator is used to check whether an object of a subclass is also an instance of the superclass.
class Animal {
}
class Dog extends Animal {
}
class Main {
public static void main(String[] args){
Dog d1 = new Dog();
System.out.println("Is d1 an instance of Dog: "+ (d1 instanceof Dog));
System.out.println("Is d1 an instance of Animal: "+ (d1 instanceof Animal));
}
}
When we run the program, the output will be:
Is d1 is an instance of Dog: true Is d1 an instance of Animal: true
In the above example, d1 is an instance of both the Dog and the Animal class. Hence, both d1 instanceof Dog
and d1 instanceof Animal
result to true
.
In Java, all the classes are inherited from the Object class. The extends
keyword is not used during the inheritance of the Object class. This is an exception in Java.
class Animal {
}
class Dog {
}
class Cat {
}
class Main {
public static void main(String[] args) {
Dog d1 = new Dog();
Animal a1 = new Animal();
Cat c1 = new Cat();
System.out.println("Is d1 an instance of the Object class: "+ (d1 instanceof Object));
System.out.println("Is a1 an instance of the Object class: "+ (a1 instanceof Object));
System.out.println("Is c1 an instance of the Object class: "+ (c1 instanceof Object));
}
}
When we run the program, the output will be:
Is d1 an instance of the Object class: true Is a1 an instance of the Object class: true Is c1 an instance of the Object class: true
In the above example, we have created objects a1, d1, and c1 of classes Animal, Dog, and Cat, respectively. We have used the instanceof
operator to check whether these objects a1, d1, and c1 are also the objects of the Object class. The output results true
for all.
This is because the Object class is the root class defined in the java.lang
package. All the other classes are child classes of the Object
class forming a hierarchy in Java.
In Java, an object of a subclass can be treated as an object of the superclass. This is called upcasting.
Java compiler automatically performs upcasting.
class Animal {
public void displayInfo() {
System.out.println("I am an animal.");
}
}
class Dog extends Animal {
}
class Main {
public static void main(String[] args) {
Dog d1 = new Dog();
Animal a1 = d1;
a1.displayInfo();
}
}
When you run the program, the output will be:
I am an animal.
In the above example, we have created an object d1 of the Dog class. We use that d1 object to create an object a1 of the Animal class with upcasting.
The code executes without any problem. This is because upcasing is automatically done by Java compilers.
Downcasting is a reverse procedure of upcasting.
In the case of downcasting, an object of the superclass is treated as an object of the subclass. We have to explicitly instruct the compiler to downcast in Java.
class Animal {
}
class Dog extends Animal {
public void displayInfo() {
System.out.println("I am a dog.");
}
}
class Main {
public static void main(String[] args) {
Dog d1 = new Dog();
Animal a1 = d1; // Upcasting
Dog d2 = (Dog)a1; // Downcasting
d2.displayInfo();
}
}
When we run the program, we will get the ClassCastException
exception. Let’s see what happens here.
Here, we have created an object a1 of the superclass Animal. We then tried to cast the a1 object to the object d1 of the subclass Dog.
This caused the problem. It is because the a1 object of the superclass Animal may also refer to other subclasses. Had we created another subclass Cat along with Dog; the Animal maybe Cat or it maybe Dog causing ambiguity.
To resolve this problem we can use the instanceof
operator. Here's how:
class Animal {
}
class Dog extends Animal {
public void displayInfo() {
System.out.println("I am a dog");
}
}
class Main {
public static void main(String[] args) {
Dog d1 = new Dog();
Animal a1 = d1; // Upcasting
if (a1 instanceof Dog){
Dog d2 = (Dog)a1; // Downcasting
d2.displayInfo();
}
}
}
When we run this program, the output will be:
I am a dog
In the above example, we use the instanceof
operator to check whether the a1 object is an instance of Dog class or not. The downcasting is done only when the expression a1 instanceof Dog
is true.
The instanceof
operator is also used to check whether an object of a class is also an instance of the interface from where the class implements.
interface Animal {
}
class Dog implements Animal {
}
class Main {
public static void main(String[] args) {
Dog d1 = new Dog();
System.out.println("Is d1 an instance of Animal: "+(d1 instanceof Animal));
}
}
When we run the program, the output will be:
Is d1 an instance of Animal: true
In the above example, we have created a class Dog that implements the Animal interface.
Then, the d1 object of the Dog class is created. We have used the instanceof
operator to check whether the d1 object is also an instance of the Animal interface.