Generics in a dynamic context - solutions?

Question

Let's assume that we have a two level hierarchy of gizmos. Say the parent class is called AbstractGizmo, with children Gizmo1, Gizmo2, Gizmo3, .....
In addition you have a Gizmo generator class to generate gizmos in a variety of ways, here is one of them
public class GizmoGenerator
   public <T extends AbstractGizmo> static T create(Class<T> cls, AdditionalParms parms)
}So to create a Gizmo you would do
Gizmo1 g1 = GizmoGenerator.create(Gizmo.class, parms );
Of course, you realize that you want to be able to substitute generators, for unit testing, and other reasons, so you decide to use a factory, and make the generator an instance with instance methods, such as
Gizmo1 g1 = GizmoFactory.getGenerator().create(Gizmo1.class, parms );
You find however that having just one generator is a pain especially for unit testing, and so you'd rather specialize at the factory, and do
Gizmo1 g1 = GizmoFactory.getGenerator(Gizmo1.class).create(parms);
The problem is, now, tho, create doesn't know how to specialize, and so this instruction has compile problems <can't cast AbstractGizmo to Gizmo1>.
Now one could pass the class to the create method as well as the factory, but that is real hinky in my mind, and what happens if you pass two different classes to the two parts... so that seems bad.
So what does one do here?
I don't want to do
Gimzo1 g1 = *(Gizmo1)*GizmoFactory.getGenerator(Gizmo1.class).create(parms);
What is the suggested solution here?

Answer 1

I don't know if this is a good solution, but here's what I came up with.
First off, I've made GizmoGenerator an interface, and added a getGizmoClass() method:
public interface GizmoGenerator<T extends AbstractGizmo>
  public Class<T> getGizmoClass();
  public T create(Object[] params);
  public T copy(T original);
}The factory methods to set the gizmo generator now only passes the generator, and the method pulls the class from the generator. I had to add type parameters to the method to make it work:
import java.util.HashMap;
public class GizmoFactory
  private static HashMap<Class, GizmoGenerator> classMap = new HashMap<Class, GizmoGenerator>();
  public static <T extends AbstractGizmo> GizmoGenerator<T> getGenerator(Class<T> clazz)
    return (GizmoGenerator<T>)classMap.get(clazz);
  public static <T extends AbstractGizmo> void setGenerator(GizmoGenerator<T> generator)
    classMap.put(generator.getGizmoClass(), generator);
  public static <T extends AbstractGizmo> void main(String[] argv)
    try
      T gz = (T)(new Gizmo1());
      Class<T> clazz = (Class<T>)Class.forName("Gizmo1");
      getGenerator(clazz).copy(gz);
    catch (Exception e)
    {  e.printStackTrace();  }
}Frankly, I don't like it. With all the casting going on, the generics are not adding any type-safety in this case. I think the root of the problem is Class.forName(), which breaks compile-time type safety. As long as that's there, everything else breaks down.