Java instanceof operator, also referred to as type comparison operator, is used to check the type of object passed. It verifies whether the reference variable contains the given type of object reference or not. Java instanceof also checks whether an object reference belongs to the parent class, child class, or an interface.
Table of Contents
The Java instanceof operator will return True if:
The Java instanceof operator will return False if:
<object> instanceof <type>
This is the basic syntax of Instanceof operator and the object mentioned here is where an object reference variable is placed. The type can be a class or an interface that has to be checked. It can be assigned to a Boolean variable as it returns true or false or it can be directly printed on the screen. See both examples here:
1. Boolean var; 2. Var = obj01 instanceof class01;
The returned value will be now stored in the variable “var”.
System.out.println(obj01 instanceof class01);
This line of code will simply output the result, true or false on screen.
Following are some of the prominent applications of instanceof Java operator. It also includes different types of verifications that instanceof operator is known for:
As discussed, the primary application of Java instanceof is testing the object reference type. The code mentioned below is a simple demonstration to understand the use of Java instanceof operator for checking reference type. Here the reference type of object (obj) is the same as the type of class (typeCheck) so it will return true.
1. public class typeCheck 2. { 3. public static void main(String[] args) 4. { 5. typeCheck obj = new typeCheck(); 6. System.out.println(obj instanceof typeCheck); 7. } 8. }
Similar to object reference check, an interface can also be checked using the instanceof operator in Java. It will return true if the reference object refers to the same interface type.
See the example below:
1. interface intf{ 2. void callMe(); 3. } 4. class example implements intf { 5. public void callMe() { 6. System.out.println(the method is called."); 7. } 8. public static void main(String[] args) { 9. inft a = new example(); 10. // Refering to the class 11. System.out.println((a instanceof example)); 12. // Refering to the interface 13. System.out.println((a instanceof intf)); 14. } 15. }
Output:
true true
In case, if the reference variable holds null value, then the instanceof will always return false like in this example below,
1. class example { 2. public static void main(String[] args) { 3. example obj = null; 4. System.out.println(obj instanceof example); 5. } 6. }
Java instanceof operator is useful for inspecting the child class, and verifies the inheritance of whether the child class is inherited or not.
Let’s take another example to understand the instanceof operator.
We created two child classes and one parent class. Now by creating objects, we will verify that the reference object belongs to which class.
Observe this simple example of code where it determines the inheritance by printing true or false.
1. class ParentClass{} 2. class Child01 extends ParentClass{} 3. class Child02 extends ParentClass{} 4. public static void main(String[] args) 5. { 6. ParentClass p =new ParentClass (); 7. Child01 c1 = new Child01(); 8. Child02 c2 = new Child02(); 9. System.out.println(p instanceof Child01); 10. System.out.println(p instanceof Child02); 11. //Both of the above statements will return false 12. //As the parent class object would never inherit a child class object. 13. System.out.println(c1 instanceof ParentClass); 14. System.out.println(c2 instanceof ParentClass); 15. //Both of these statements will return true as it is correct inheritance. 16. p = c1; 17. System.out.println(p1 instanceof Child01); 18. System.out.println(p1 instanceof Child02); 19. //A child object has been assigned to a parent object so the first statement 20. //should be true as the object was of child01 but the second statement will be false. 21. } 22. }
The output of this code will be:
false false true true true false
As String is a class in Java, string data can also be verified using the instanceof operator. Although this application might seem not to be very useful in a certain case where you are not sure whether the data type is a string or not, you can first check it using instanceof to prevent any errors.
1. Class example{ 2. Public static void main(String·args[]) { 3. String str = "It’s a simple string"; 4. Int var = 34; 5. if(str1 instanceof String) 6. System.out.println("str is an instance of the String class");· 7. else 8. System.out.println("str is NOT an instance of the String class"); 9. if(var instanceof String) 10. System.out.println("str is an instance of the String class");· 11. else 12. System.out.println("str is NOT an instance of the String class"); 13. } 14. }
str is an instance of the String class str is NOT an instance of the String class
Downcasting is the process of holding an object of a parent class in a child class reference object. It is the opposite of upcasting, in which an object of the child class is assigned to the parent class reference object.
Downcasting can be easily done without using instanceof operator like this,
1. class parentClass { } 2. class childClass extends parentClass { 3. static void method(parentClass p) { 4. childClass c = (childClass) p; 5. System.out.println("downcasting is completed."); 6. } 7. } 8. public static void main(String arg[]) { 9. parentClass p = new childClass(); 10. childClass.method(p); 11. } 12. }
The problem in downcasting like this is that here you will encounter a “ClassCastException” exception due to Class Casting done in line 3.
Java instanceof operator takes care of that and also comes in handy when typecasting. It is recommended to check the validity of typecasting first. Instanceof is used here to check whether the typecasting is valid or not before downcasting.
Now, see this example of downcasting is performed using Java instanceof operator:
class ParentClass{ } public class ChildClass extends ParentClass { public void method() { System.out.println("Downcasting performed Successfully"); } public static void show(ParentClass p) { if(p instanceof ChildClass) { ChildClass c = (ChildClass) p; c.method(); } } public static void main(String[] args) { parentClass p =new childClass(); childClass.show(p); } }
Downcasting performed Successfully
Here, we have created a parent class and extended it with a child class. Until now, the code is functioning the same as the one without using the instanceof operator. Now we have another method where the instanceof operator is used to hold the parent class object (p) with the reference to child class object (c).
If the instanceof operator returns true, only then will you be able to downcast successfully and a message will appear on the screen saying so.
See Also: Here’s How to Fix the “Could Not Find or Load Main Class” Error in Java
Java instanceof is a simple operator that primarily deals with the testing of the data type of object reference. It also includes checking that the instance should be of a specified type of class, subclass, or interface. Inheritance checking and downcasting are other notable applications of instanceof that can prevent exceptions and errors in your code. If used properly, the instanceof operator can be utilized to significantly reduce the occurrences of errors and exceptions in your program.
Shaharyar Lalani is a developer with a strong interest in business analysis, project management, and UX design. He writes and teaches extensively on themes current in the world of web and app development, especially in Java technology.
Create a free profile and find your next great opportunity.
Sign up and find a perfect match for your team.
Xperti vets skilled professionals with its unique talent-matching process.
Connect and engage with technology enthusiasts.
© Xperti.io All Rights Reserved
Privacy
Terms of use