The error message says it all. At runtime, the type is gone, there is no way to check for it. You could catch it by making a factory for your object like this: public static <T> MyObject<T> createMyObject(Class<T> type) { return new MyObject<T>(type); } And then in the object’s constructor store that type, so variable … Read more
Use instanceof for custom types: var ClassFirst = function () {}; var ClassSecond = function () {}; var instance = new ClassFirst(); typeof instance; // object typeof instance == ‘ClassFirst’; // false instance instanceof Object; // true instance instanceof ClassFirst; // true instance instanceof ClassSecond; // false Use typeof for simple built in types: ‘example … Read more
A related issue that I have come across recently (and which led me to this page, before I figured out what was going on) is that the Eclipse environment can report “Incompatible conditional operand types” in an ‘instanceof’ expression erroneously due to a missing ‘import’ statement for the type on the right of the ‘instanceof’. … Read more
instanceof The Left Hand Side (LHS) operand is the actual object being tested to the Right Hand Side (RHS) operand which is the actual constructor of a class. The basic definition is: Checks the current object and returns true if the object is of the specified object type. Here are some good examples and here … Read more
This is a typical scenario where subtype polymorphism helps. Do the following interface I { void do(); } class A implements I { void do() { doA() } … } class B implements I { void do() { doB() } … } class C implements I { void do() { doC() } … } Then … Read more
You might be interested in this entry from Steve Yegge’s Amazon blog: “when polymorphism fails”. Essentially he’s addressing cases like this, when polymorphism causes more trouble than it solves. The issue is that to use polymorphism you have to make the logic of “handle” part of each ‘switching’ class – i.e. Integer etc. in this … Read more
Try using: if(NewType* v = dynamic_cast<NewType*>(old)) { // old was safely casted to NewType v->doSomething(); } This requires your compiler to have rtti support enabled. EDIT: I’ve had some good comments on this answer! Every time you need to use a dynamic_cast (or instanceof) you’d better ask yourself whether it’s a necessary thing. It’s generally … Read more
Approach I wrote a benchmark program to evaluate different implementations: instanceof implementation (as reference) object-orientated via an abstract class and @Override a test method using an own type implementation getClass() == _.class implementation I used jmh to run the benchmark with 100 warmup calls, 1000 iterations under measuring, and with 10 forks. So each option … Read more
Josh Bloch favors your approach: The reason that I favor the instanceof approach is that when you use the getClass approach, you have the restriction that objects are only equal to other objects of the same class, the same run time type. If you extend a class and add a couple of innocuous methods to … Read more
When using instanceof, you need to know the class of B at compile time. When using isAssignableFrom() it can be dynamic and change during runtime.