Re: Can this callback mechanism be generified?

I managed to make the API just slightly easier to use, by extracting the
type from Callback<T> rather than requiring an explicit Class to be
supplied along with it. It's not pretty but I'm not sure of how to
extract type T, since I guess its not readily available on the account
of generics by erasure:

interface Callback<T> {
      String format(T object);
  }

class Somewhere {
      Map<Class<?>, Callback<?>> callbacks
           = new HashMap<Class<?>, Callback<?>>();

      public <T> void installCallback(Callback<T> callback) {

          callbacks.put(extractGenericType( callback ), callback);
      }

     private <T> Class extractGenericType(Callback<T> callback){
         Class clazz = Object.class;
         String interfaces =
callback.getClass().getGenericInterfaces()[0].toString();
         int genTypeStart = interfaces.indexOf("<")+1;
         int genTypeEnd = interfaces.lastIndexOf(">");
         String genType = interfaces.substring( genTypeStart, genTypeEnd);

         try{
             clazz = Class.forName(genType);
         }
         catch (ClassNotFoundException ex){}

         return clazz;
     }

      public <T> void doCallback(T obj) {
          final Callback<? super T> callback = getCallback(obj);
          if(callback != null)
              System.out.println( callback.format( obj ) );
      }

      @SuppressWarnings({"unchecked"})
      private <T> Callback<? super T> getCallback(T obj) {
          return (Callback<? super T>) callbacks.get(obj.getClass());
      }
  }

class Main {
     public static void main(String[] args) {
         new Somewhere().installCallback( new Callback<Date>(){
             public String format(Date date) {
                 return SimpleDateFormat.getInstance().format(date);
             }
         });
     }
}

/Casper