If you need to find out the type of object then you aren't using
generics properly, or you should learn (as I did recently!) about the
Visitor pattern.

An example of not using generics properly:

E.g.: List<Object> objects=new ArrayList<Object>();
objects.add("blah");
System.out.println((String)objects.get(0)).length());

Of course, String and Object could be any subtype and supertype.

The reason this is bad is that I would be better off using List<String>
strings=new ArrayList<String>();, then I *know* it's a String.

An example where the Visitor pattern might be more useful:

interface Supertype
{
}

final class Subtype implements Supertype
{
}

final class Subtype2 implements Supertype
{
}

List<Supertype> objects=new List<Supertype>();
objects.add(new Subtype());
objects.add(new Subtype2());

Supertype object=objects.get((int)(Math.random()*2)); //pick an element
at random.
if (object instanceof Subtype)
  System.out.println("Yo, dude, it's the first one!");
else
  System.out.println("Must be the second.");

I would change this to use the Visitor pattern, which at first glance
is more verbose, but you get used to it.  I'm still getting used to it.

final class Visitor
{
  public void visit(Subtype subtype)
  {
     System.out.println("Must be the first.");
  }

  public void visit(Subtype2 subtype2)
  {
     System.out.println("Must be the second.");
  }
}

interface Supertype
{
  void accept(Visitor visitor);
}

final class Subtype implements Supertype
{
  void accept(Visitor visitor)
  {
     visitor.visit(this);  //calls the first method in Visitor.
  }
}

final class Subtype2 implements Supertype
{
  void accept(Visitor visitor)
  {
     visitor.visit(this); //calls the second method in Visitor.
  }
}

Then:

List<Supertype> objects=new List<Supertype>();
objects.add(new Subtype());
objects.add(new Subtype2());

Supertype object=objects.get((int)(Math.random()*2)); //pick an element
at random.
object.accept(new Visitor());

Look, no casts!  No instanceof either.  Just polymorphic goodness.

I will readily admit that I am not completely comfortable with this,
I'm trying it out on some of my code, but I can see immediately that it
will stop me from writing an error-prone if..else tree (one error is
simply to miss out a subtype).  If it prevents bugs, I'm happy.