Halcyon.Wild@gmail.com wrote in comp.lang.java.programmer:

    This is not a new subject. Search Google.

    One of the obvious reasons is that every time you use
    instanceof you are hardcoding a class name.

Many responders have pointed out some of the reasons to minimize the us
of instanceof, but there are many times when it is your friend.

Consider a GUI application that needs to determine the Window (or
Dialog, or Frame, etc.) ancestor of a GUI component. The easiest way is
to walk the parent tree up until finding a parent that is "instanceof
Window".

From the arguments in the previous posts, it is best to avoid casts and
instanceof statements as much as possible.
But sometimes it can have its use.

One situation is the use of so-called 'Marker Interfaces'. An example is
java.io.Serializable.
Such an interface does not declare any methods. Instead it declares a
contract between objects implementing the marker-interface and the users of
such objects and this type of contract can not be expressed with
declarations, using java syntax.

As an example:  how would one express the contract of java.io.Serializable
in plain java-code? (the contract stating - in short - that objects
implementing java.io.Serializable must have members that are either
serializable as well or that are volatile)

The user of objects implementing marker-interfaces make use of the
instanceof statement.

What do you all think about using these marker-interfaces?

URL to definition: http://tinyurl.com/djr49
-- Anton.

I think avoiding hardcoding of class names is a silly reason not to use
instance of.  The reason not to use it is because objects should
describe thier own behavior.  If you move all the behavior out of the
object into scattered instanceof's, then its very hard to figure out
what the object actually does.  The reason instanceof is fine in an
equals method, is that its looking for an instance of the current
class, still describing its own behavior.

Hi all,
First of all, Thanks a lot to all of you. Helped me clear up my
confusion to some extent.
I was trying out examples posted by people on this thread. I picked up
on examples given by Shakah, Thomas Weidenfeller and Dale King, and
worked upon it.

See Listing 1. I was thinking what if it is not possible to have a
common base class for the two subclasses, for example, I decide that
MyCircle and MySquare are two different classes altogether. Now I
create a MyCircle instance and a MySquare instance. And call a local
overloaded getArea() method. Whatever is passed, it recognizes the
correct call, and calls the appropriate class method to calc the area.
Note that passing MyShape instance will not work, in case you pass
MyShape and do not overload getArea() to receive MyShape parameter.
Polymorphism is one way here.

The Listing 2 changes a bit. I added getShape() method which returns
MyShape. Now MyCircle and MySquare are subclasses of MyShape. I do not
know what getShape() will return me. I can very well put MySquare
there, instead of MyCircle. And it works fine.
One dead end. I cannot modify MyCircle properties using the MyShape
ref, like setting the radius (in case i do not use the constructor to
set radius). I would need to know what shape it exactly is, so that I
know I want to change the radius or the length of the shape.

Here is one situation where you would want to use instanceof or
getClass().getName(); Let me know if I am wrong. Also let me know if
you need any clarifications. Sooner or Later, I will get back.

Listing 1.
//save in YourClass.java
public class YourClass {

    public double getArea(MyCircle circle) {
        return circle.calcArea() ;
    }

    public double getArea(MySquare square) {
        return square.calcArea();
    }

    public static void main(String args[])    {
        YourClass y = new YourClass();
        MyCircle circle = new MyCircle();
        MySquare square = new MySquare();
        circle.setRadius(10.0);
        square.setLength(10.0);
        System.out.println(y.getArea(circle));
        System.out.println(y.getArea(square));
    }
}

class MyCircle
{
    private double dRadius_;
    public void setRadius(double r)
    {
        this.dRadius_ = r;
    }
    public double calcArea()
    {
        return (3.14159 * dRadius_ * dRadius_);
    }
}

class MySquare
{
    private double dLength_;
    public void setLength(double l)
    {
        this.dLength_ = l;
    }
    public double calcArea()
    {
        return (dLength_ * dLength_);
    }
}

=====================================

listing 2
public class YourClass {
    public MyShape getShape()
    {
        MyShape shape = new MyCircle(10.0);
        return shape;
    }

    public static void main(String args[])    {
        YourClass y = new YourClass();
        MyShape s = y.getShape();
        System.out.println(s.calcArea());
    }
}

abstract class MyShape {
   public abstract double calcArea() ;
}

class MyCircle extends MyShape
{
    private double dRadius_;
    public MyCircle()
    {
        this.dRadius_ = 0.0;
    }
    public MyCircle(double d)
    {
        this.dRadius_ = d;
    }
    public void setRadius(double r)
    {
        this.dRadius_ = r;
    }
    public double calcArea()
    {
        return (3.14159 * dRadius_ * dRadius_);
    }
}

class MySquare extends MyShape
{
    private double dLength_;
    public void setLength(double l)
    {
        this.dLength_ = l;
    }
    public double calcArea()
    {
        return (dLength_ * dLength_);
    }
}