Dynamic class type casting?

Question

Anyone know how to synthesize changing the type of a class after the instance is created?
I have a base class that has a number of sub classes. When instances are created, I cannot create subclass instances because the required information is not available. However, after the instances are created, I can determine the subclass I would like the instance to be.
The subclasses don't have any new fields, they just override base class methods. The subclass I want is determined by a field in the base class that is not known at base class creation time. It is set at a later point.
Any ideas?
I could delay object creation until I know exactly which sub classs I want, but that would increase code size considerably. I would like a neat mutation mechanism or something similar so I could change the type of the class.
I could also recreate the object when I know the subclass I want, but that seems expensive.

Answer 1

I have a base class that has a number of sub classes.
When instances are created, I cannot create subclass
instances because the required information is not
available. However, after the instances are created, I
can determine the subclass I would like the instance
to be.You might consider the prototype pattern. In the prototype pattern, you have a prototype manager and prototype objects it manages. You register prototypes with the prototype manager using a key (think of a key abstractly here) and retrieve the prototypes using the same key. When you retrieve a prototype from the prototype manager you clone the prototype, which is much faster than instantiating an object, and then you use the clone.
From what you said above it seems that you have all of the right elements for application of the pattern. You said you have a base class with many sub-classes and that you know which sub-class you want when you have specific information.
>
The subclasses don't have any new fields, they just
override base class methods. The subclass I want is
determined by a field in the base class that is not
known at base class creation time. It is set at a
later point.
In implementing the pattern it would be a good idea to create a new class that manages the information you require (as previosuly determined by the field in the base class) to create a subclass, removing it (the field) from the base class completely. This new class is used as your key to retrieve prototypes from the prototype manager.public class OldBaseNowIsKey {
   String field;
   public String getField() { return field; }
   public void setField(String s) { field = s; }
public class NewBaseClass {
   public void doSomethingPolymorphic() { }
public class PrototypeOne extends NewBaseClass {
   public void doSomethingPolymorphic() { }
public class PrototypeManager {
   private Hashmap prototypes;
   static {
      // This is one way to register prototypes and not
      // necessarily the best.
      prototypes = new Hashmap();
      prototypes.put("prototypeOneKey", new PrototypeOne());
   public static NewBaseClass get(OldBaseNowIsKey key) {
      return (NewBaseClass) prototypes(key.getField());
public class ClassThatUsesPrototype {
   public void someMethod() {
      // Something happens and we know the value of the
      // field in the old base class but now we use that
      // information to create a key or reuse an existing
      // key object.
      OldBaseNowIsKey key = new OldBaseNowIsKey();
      key.setField(theInformation);
      // Now we know have the necessary information to
      // create a sub-class only we will be cloning which
      // is faster.
      NewBaseClass prototype = PrototypeManager.get(key).clone();
      prototype.doSomethingPolymorphic();
I could delay object creation until I know exactly
which sub classs I want, but that would increase code
size considerably. I would like a neat mutation
mechanism or something similar so I could change the
type of the class.Sounds like C++.