If class B
and class C
extend class A
and I have an object of type B
or C
, how can I determine of which type it is an instance?
This question is related to
java
inheritance
if (obj instanceof C) {
//your code
}
checking with isinstance()
would not be enough if you want to know in run time.
use:
if(someObject.getClass().equals(C.class){
// do something
}
I use the blow function in my GeneralUtils class, check it may be useful
public String getFieldType(Object o) {
if (o == null) {
return "Unable to identify the class name";
}
return o.getClass().getName();
}
Any use of any of the methods suggested is considered a code smell which is based in a bad OO design.
If your design is good, you should not find yourself needing to use getClass()
or instanceof
.
Any of the suggested methods will do, but just something to keep in mind, design-wise.
We can use reflection in this case
objectName.getClass().getName();
Example:-
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String name = request.getClass().getName();
}
In this case you will get name of the class which object pass to HttpServletRequest
interface refference variable.
You can use getSimpleName().
Let's say we have a object: Dog d = new Dog(),
The we can use below statement to get the class name: Dog. E.g.:
d.getClass().getSimpleName(); // return String 'Dog'.
PS: d.getClass() will give you the full name of your object.
Multiple right answers were presented, but there are still more methods: Class.isAssignableFrom()
and simply attempting to cast the object (which might throw a ClassCastException
).
Let's summarize the possible ways to test if an object obj
is an instance of type C
:
// Method #1
if (obj instanceof C)
;
// Method #2
if (C.class.isInstance(obj))
;
// Method #3
if (C.class.isAssignableFrom(obj.getClass()))
;
// Method #4
try {
C c = (C) obj;
// No exception: obj is of type C or IT MIGHT BE NULL!
} catch (ClassCastException e) {
}
// Method #5
try {
C c = C.class.cast(obj);
// No exception: obj is of type C or IT MIGHT BE NULL!
} catch (ClassCastException e) {
}
null
handlingThere is a difference in null
handling though:
false
if obj
is null
(null
is not instance of anything).NullPointerException
obviously. null
because null
can be cast to any type!To remember:
null
is not an instance of any type but it can be cast to any type.
Class.getName()
should not be used to perform an "is-instance-of" test becase if the object is not of type C
but a subclass of it, it may have a completely different name and package (therefore class names will obviously not match) but it is still of type C
.Class.isAssignableFrom()
is not symmetric:obj.getClass().isAssignableFrom(C.class)
would return false
if the type of obj
is a subclass of C
.You can use:
Object instance = new SomeClass();
instance.getClass().getName(); //will return the name (as String) (== "SomeClass")
instance.getClass(); //will return the SomeClass' Class object
HTH. But I think most of the time it is no good practice to use that for control flow or something similar...
I Used Java 8 generics to get what is the object instance at runtime rather than having to use switch case
public <T> void print(T data) {
System.out.println(data.getClass().getName()+" => The data is " + data);
}
pass any type of data and the method will print the type of data you passed while calling it. eg
String str = "Hello World";
int number = 10;
double decimal = 10.0;
float f = 10F;
long l = 10L;
List list = new ArrayList();
print(str);
print(number);
print(decimal);
print(f);
print(l);
print(list);
Following is the output
java.lang.String => The data is Hello World
java.lang.Integer => The data is 10
java.lang.Double => The data is 10.0
java.lang.Float => The data is 10.0
java.lang.Long => The data is 10
java.util.ArrayList => The data is []
Use Object.getClass(). It returns the runtime type of the object.
There is also an .isInstance
method on the "Class
" class. if you get an object's class via myBanana.getClass()
you can see if your object myApple
is an instance of the same class as myBanana
via
myBanana.getClass().isInstance(myApple)
Source: Stackoverflow.com