Re: Wrapper for multiple instanceof
On Aug 22, 8:07 am, getsanjay.sha...@gmail.com wrote:
Thanks a lot Joshua for putting things right, I knew there was some
bit missing, I guess it was the isInstance() method. And like Patricia
said, in this scenario the || or | didn't make a difference since I
was anyways breaking out of the loop if any of the class satisfied the
condition.
Thank you Patricia for clarifying in my absence, and oh, what we would
do without your JLS plugs. :-)
On Aug 22, 6:47 am, Lew <l...@lewscanon.com> wrote:
getsanjay.sha...@gmail.com wrote:
[...]
Notice the client code doesn't "know" that doer is "really" a HelloWorld, or
some other implementing class. It just lets the object "know" what to do for
itself. No run-time type checking needed on your part.
This idiom is at the heart of object-oriented programming.
Thanks a lot Lew for letting me know of this. But this concept is
still a bit hazy to me. Can you provide a real world example on how
your paradigm can be put to use?
Thanks Roedy, like always, your link was really helpful. :)
And Bent, your method gave me an alternate solution to my problem.
Both isInstance() and isAssignableFrom() really seem to do the trick.
Thank you.
On Aug 22, 6:48 pm, Twisted <twisted...@gmail.com> wrote:
On Aug 21, 9:01 pm, getsanjay.sha...@gmail.com wrote:
public static boolean check(Object obj, String...classes) throws
Exception
{
boolean result = false;
for(String str : classes)
{
Class c = Class.forName(str);
result = result | (obj instanceof c);
if(result) break;
}
return(result);
}
Good Lord! When I saw the subject line I held my nose and clicked the
link to read the post, expecting something interesting but with a fair
bit of code smell.
This goes way beyond code smell -- I think maybe something crawled in
there and died!
Its OK my friend, we all try to learn. Maybe by writing smelly code
but creative code today, I would live tomorrow to write better code...
Thanks and regards,
STS.
Start with your the bad instanceof check:
class Foo {}
class Bar {}
class Baz {}
class NeedsToKnow {
public void needsToKnow(Object o) {
if ((o instanceof Foo) || o instanceof Bar) {
System.out.println("Fubar!");
} else {
System.out.println("Not Fubar!");
}
}
}
-----------
Refactoring to polymorphism gives you something like:
interface Knowable {
void needsToKnow();
}
abstract class Fubar implements Knowable{
public void needsToKnow() {
System.out.println("Fubar!");
}
}
/* Note, that these are free to further change the rules for
needsToKnow if they need to know.
class Foo extends Fubar {}
class Bar extends Fubar {}
class Baz implements Knowable {
public void needsToKnow() {
System.out.println("Not Fubar!");
}
}
class NeedsToKnow {
/* Note that Object o becomes Knowable o */
public void needsToKnow(Knowable o) {
/* Note the delegation. Tell, don't ask */
o.needsToKnow();
}
}