Thank you very much for your reply. That worked perfectly (although I
agree, not idea at all).

I can better explain the problem by sending a little code, but I must
prefix it with the fact that I did not write this.

The code is basically an Enum, and a global enum repository. It looks
basically like (I'll cut out what I can):

class AEnum
{
   private static AEnum One = (AEnum) EnumRegistry.add(new
AEnum("One"));
   private static AEnum Two = (AEnum) EnumRegistry.add(new
AEnum("Two"));
   // private constructor
}

class EnumRegistry
{
   private static Map classMap = new HashMap();
  public static synchronized Object add(Object enumerationObj)
   {
       java.util.HashMap enumMap;  // A mapping for a particular
class, value->enum

       if (classMap.containsKey(enumerationObj.getClass()))
       {
           enumMap = (HashMap)
classMap.get(enumerationObj.getClass());
       }
       else
       {
           enumMap = new HashMap();
       }
       enumMap.put(enumerationObj.toString(), enumerationObj);
       classMap.put(enumerationObj.getClass(), enumMap);
       return enumerationObj;
   }

   public static synchronized Object
   getEnum(Class enumClass, String value) throws EnumException
   {
       HashMap enumMap = (HashMap) classMap.get(enumClass);
       if (enumMap == null || !enumMap.containsKey(value))
       {
           throw new EnumException("enum value: '" + value + "' not
found");
       }
       return enumMap.get(value);
   }
}

The code that ends up calling this basically goes:
AEnum blah = (AEnum) EnumRegistry.getEnum(AEnum.class, "One");

Now this use to cause AEnum.class's static fields to be created, so it
would populate the registry, but it doesn't.

Thanks again for your quick reply,

Kenny

On Mon, 13 Feb 2006 20:00:03 -0000, "Chris Uppal"
<chris.uppal@metagnostic.REMOVE-THIS.org> wrote, quoted or indirectly
quoted someone who said :

this sounds like "if a tree falls in the forest, when there is no one
to hear it, does it make a sound" sort of questions.

In what sort of instance does it make a difference precisely when the
statics are initialised? Is this a matter of where you catch
exceptions in static init code?

I don't think that's true.  Assuming that the wording in the JLS is deliberate,
the 1.4 series JVMs were all seriously buggy in this respect.  The JLS does not
leave it /open/ whether initialisation happens in this case -- it clearly[*]
states that initialisation is /not/ permitted.  No "difference in behavior" is
"allowed by the language and platform specifications".

As I have said, I believe that the JLS itself is at fault here, and thus that
the 1.5 series JVMs are /also/ at fault, wheras the 1.4 series were correct.
I'm willing to be persuaded otherwise, but that's my current opinion.  Whatever
the truth of the matter, the /change/ in behaviour is not a good thing.

(
[*] There's some fudged wording in the "spec":

   Invocation of certain reflective methods in class Class
   and in package java.lang.reflect also causes class or
   interface initialization.

"certain reflective methods" -- great!  That /really/ ties down the
specification...  Anyway, neither of the cases mentioned apply here, so we can
rely on the next sentence:

   A class or interface will not be initialized under any
   other circumstance.
)

   -- chris

An ExceptionInInitializerError gets thrown

Which is why i would try and keep its effects strictly contained within
that one class. How, and when the class performs its internal
housekeeping is its own business, but i would strongly suggest not
mucking around too much.

It probably is, however it will depend on the bytecode instead of the
source code, and therefore is highly arcane, and not something you
should rely on.