Tener una cadena de operaciones de "instancia de" se considera un "olor a código". La respuesta estándar es "usar polimorfismo". ¿Cómo lo haría en este caso?

Hay varias subclases de una clase base; ninguno de ellos está bajo mi control. Una situación análoga sería con las clases Java Integer, Double, BigDecimal, etc.

if (obj instanceof Integer) {NumberStuff.handle((Integer)obj);}
else if (obj instanceof BigDecimal) {BigDecimalStuff.handle((BigDecimal)obj);}
else if (obj instanceof Double) {DoubleStuff.handle((Double)obj);}

Tengo control sobre NumberStuff y así sucesivamente.

No quiero usar muchas líneas de código donde algunas líneas harían. (A veces hago un mapeo de HashMap Integer.class a una instancia de IntegerStuff, BigDecimal.class a una instancia de BigDecimalStuff, etc. Pero hoy quiero algo más simple).

Me gustaría algo tan simple como esto:

public static handle(Integer num) { ... }
public static handle(BigDecimal num) { ... }

Pero Java simplemente no funciona de esa manera.

Me gustaría usar métodos estáticos al formatear. Las cosas que estoy formateando son compuestas, donde una Thing1 puede contener una matriz Thing2s y una Thing2 puede contener una matriz de Thing1s. Tuve un problema cuando implementé mis formateadores de esta manera:

class Thing1Formatter {
  private static Thing2Formatter thing2Formatter = new Thing2Formatter();
  public format(Thing thing) {
      thing2Formatter.format(thing.innerThing2);
  }
}
class Thing2Formatter {
  private static Thing1Formatter thing1Formatter = new Thing1Formatter();
  public format(Thing2 thing) {
      thing1Formatter.format(thing.innerThing1);
  }
}

Sí, conozco el HashMap y un poco más de código también puede solucionarlo. Pero la "instancia de" parece tan fácil de leer y mantener en comparación. ¿Hay algo simple pero no maloliente?

Nota agregada 10/05/2010:

Resulta que probablemente se agregarán nuevas subclases en el futuro, y mi código existente tendrá que manejarlas con gracia. El HashMap en clase no funcionará en ese caso porque no se encontrará la clase. Una cadena de declaraciones if, comenzando con la más específica y terminando con la más general, es probablemente la mejor después de todo:

if (obj instanceof SubClass1) {
    // Handle all the methods and properties of SubClass1
} else if (obj instanceof SubClass2) {
    // Handle all the methods and properties of SubClass2
} else if (obj instanceof Interface3) {
    // Unknown class but it implements Interface3
    // so handle those methods and properties
} else if (obj instanceof Interface4) {
    // likewise.  May want to also handle case of
    // object that implements both interfaces.
} else {
    // New (unknown) subclass; do what I can with the base class
}