How to garantee that static data is initialized ?

Question

Hi,
In order to implement the Prototype design pattern in Java I would like to automatically register the subclasses of Prototype to a static array of prototypes in the Prototype class.
In C++ I use a static member in each subclass which is initialized by a static method which registers a prototype in the array of prototypes.
It works in C++ because static data are initialized before main() is called.
In Java though, to guarantee that static data is initialized it seems that each subclass needs to be loaded first which defeats the idea of automatic registration.
Another solution to avoid mentionning subclasses names in the Prototype class would be to rely on the relfection API to get all its subclasses but I did not find any method to do that.
Any hint ?
Thanks in advance

Answer 1

It depends what you call a key. In database systems a
key is part of the data you are looking for.
In order to get a specific prototype one of course
needs information.
Do we disagree here ?If you read the Prototype design pattern you will understand what I mean by key.
The objective of the Prototype pattern is to decouple
client code from which classes implement (or subclass)
the Prototype interface (or abstract class).
I disagree. It is a creational pattern. The intent of the Prototype pattern is to create a prototypical instance and create new objects by copying the prototype. The intent is not to decouple client code.
Let's get back to my original question : is there a
way in Java to register a class automatically to the
collection of prototypes ?
Using the reflection API gives an alternative solution
(thanks to schapel).And I restate my orignal solution as my answer. Why would you want look through all or your classes to determine which ones where prototypes (sorry schapel)?
If you have a known number of prototype subclasses then you can create and intialize them when the Prototype class is loaded.
If not then you can use the key to determine if the prototype has been loaded, if not then the Prototype class can load the class. In this case, with some creativitity, you can create a key that meets your needs.
It seems that you are dependent on the Prototype class containing all of the prototype classes at load time because you are using them to create user interface components. So your client (use interface) is directly coupled to your implementation of the Prototype, exactly what you said the Prototype design pattern incorrectly was intended to do.