Java实例化对象，直到运行时才知道它属于哪个子类

Question

Scenario: I have a hierarchy of subclasses all inheriting from a single distance ancestral class. All super classes in the hierarchy are abstract, so the only concrete classes are those without subclasses. I have an array:

AncestralClass[] someObjects1 = new AncestralClass[someLength];

The ancestralClass is the single super class at the top of the hierarchy that all other classes inherit from. This array is populated with different objects of the various concrete subclasses. For example:

someObjects1[4] = new SubclassObject();

... and so on.

I have a second array of the same exact form (same type, size, etc), but the second array uses the first array to populate itself with objects again belonging to the various concrete subclasses. To be more specific, the object type in an element in the second array, will be decided based on the object type found in the same element of the first array. So the problem I have is this: I won't know what is contained in the first array because its contents are generated randomly at runtime, therefore I will not know what the contents of the second array should be as they are dependent on the first array. I am not sure how to write the code that instantiates the new objects in the second array. Written in English, what I want to happen sounds so simple and easy. I want to loop through the second array, check the corresponding position in the first array, check what kind of object that is, and then instantiate a new object of that type in the second array. That right there is what I don't know how to code:

someObjects2[i] = new (subclass that someObjects1[i] belongs to)(); 

Question To be more general, I want to instantiate a new object that is a new instance of a class an existing object belongs to. How do I do this, and I'm sure there's multiple solutions, so which is better?

Answer 1

It seems from your description that you know beforehand the set of possible concrete classes in the first array. You can do something like:

for (int i = 0; i < array1.length; i++) {
    if (array1[i] instanceof SubclassObject1) {
        array2[i] = new SubclassObject1();
    } else if (array1[i] instanceof SubclassObject2) {
        array2[i] = new SubclassObject2();
    }
    ....
}

Answer 2

I think this idea is sort of dubious. There's all sorts of problems you can run into trying to create classes of types you don't control in advance.

So if I did this, the first thing I would do is to use a simple factory method, which is the most basic creational pattern. This way you have all your code isolated in one spot, so if you need to change it later, you can. Then I would just use reflection to create the object.

public class Creation
{
   private Creation() {}

   public static <S, T extends S> S makeNew( T obj )
           throws InstantiationException, IllegalAccessException
   {
      return (S) ( obj.getClass().newInstance() );
   }

   // Demonstration
   public static void main( String[] args )
           throws InstantiationException, IllegalAccessException
   {
      CharSequence[] cs = { new StringBuilder(), new Segment()  };
      for( CharSequence c : cs ) System.out.println( makeNew( c ) );
   }
}

This will work for simple cases. If you need to use a fancy library like Objenesis in the future, you have an easy place to make your changes.