The main difference between if…else… (or switch, or Visitor), and between polymorphism is modularity. There’s so called open-closed principle, which basically means, that when you add a new feature to an existing program, the less changes you make in existing code the better (because every change requires some work, and may introduce bugs). So let’s … Read more
If it suffices to use subtyping checks on erased types, do as Travis Brown suggested in the comment above: def myIsInstanceOf[T: ClassTag](that: Any) = classTag[T].runtimeClass.isInstance(that) Otherwise you need to explicitly spell out the U type, so that scalac captures its type in a type tag: def myIsInstanceOf[T: TypeTag, U: TypeTag] = typeOf[U] <:< typeOf[T]
The instanceof operator works on reference types, like Integer, and not on objects, like new Integer(213). You probably want something like clazz.isInstance(obj) Side note: your code will be more concise if you write public boolean isOf(Class clazz, Object obj){ return clazz.isInstance(obj) } Not really sure if you need a method anymore ,though.
The reason that the performance of instanceof and getClass() == … is different is that they are doing different things. instanceof tests whether the object reference on the left-hand side (LHS) is an instance of the type on the right-hand side (RHS) or some subtype. getClass() == … tests whether the types are identical. So … Read more
The only way you can do this check is if you have the Class object representing the type: Class<T> type; //maybe passed into the method if ( type.isInstance(obj) ) { //… }
The instanceof-operator is called is in Dart. The spec isn’t exactly friendly to a casual reader, so the best description right now seems to be http://www.dartlang.org/articles/optional-types/. Here’s an example: class Foo { } main() { var foo = new Foo(); if (foo is Foo) { print(“it’s a foo!”); } }
Here is an approach that does not deal with class names at all, and dispatches as fast as a switch statement does: make a hash map to map Class<T> objects to class-specific handlers, and use the map instead of a switch: // Declare an interface for your polymorphic handlers to implement. // There will be … Read more
Are you looking for: Super.class.isAssignableFrom(Sub.class)
instanceof simply breaks the Open/Close principle. and/or Liskov substitution principle If we are not enough abstract because of instanceof usage, each time a new subclass makes an entrance, the main code gathering the logic of the application might be updated. This is clearly not what we want, since it could potentially break the existing code … Read more
TL;DR instanceof works with classes, not interfaces nor type aliases. What’s TypeScript trying to tell me? The issue is that instanceof is a construct from JavaScript, and in JavaScript, instanceof expects a value for the right-side operand. Specifically, in x instanceof Foo JavaScript will perform a runtime check to see whether Foo.prototype exists anywhere in … Read more