There are some things that only the Creator(s) can explain !

[Gurucharan Murudeshwar]

Hello All,
Try out this program :
==================================================
public class TestStatic {

static
{
System.out.println("This is strange !!!");
}
public static void main(String args[]) {
TestStatic ts = new TestStatic();
}

}
==================================================

What would we expect ?
A compilation error ?
But this prints :
+--------------------------------+
| |
| This is strange !!! |
| |
+--------------------------------+
on the screen .
Any explanations ?
We are preparing for the JDK-1.4 Exam.
Cheers,
gurucharan

[Barkat Mardhani]

When a class is accessed for the first time, the static block is executed. That is why you are getting that output.
[ February 19, 2003: Message edited by: Barkat Mardhani ]

[Sridhar Srikanthan]

Originally posted by Gurucharan Murudeshwar:
Hello All,
Try out this program :
==================================================
public class TestStatic {

static
{
System.out.println("This is strange !!!");
}
public static void main(String args[]) {
TestStatic ts = new TestStatic();
}

}
==================================================

What would we expect ?
A compilation error ?
But this prints :
+--------------------------------+
| |
| This is strange !!! |
| |
+--------------------------------+
on the screen .
Any explanations ?
We are preparing for the JDK-1.4 Exam.
Cheers,
gurucharan

There is nothing strange about it.
static {} is called a static initializer
A static initializer block executes only once and this happens even before an instance of the class is created.
i,e even before
TestStatic ts = new TestStatic();
Hope this helps,
Sri
---------------
when in doubt, refer to Java Language Specification
[ February 19, 2003: Message edited by: Sri Sri ]

[Gurucharan Murudeshwar]

Yes.
But is this a normal behaviour ?
Cheers.

[Sridhar Srikanthan]

Originally posted by Gurucharan Murudeshwar:
Yes.
But is this a normal behaviour ?
Cheers.

Yes that is the normal behaviour.
some more to start with

https://coderanch.com/t/192804/java-programmer-SCJP/certification/Static-Initializers[/URL]
https://coderanch.com/t/194459/java-programmer-SCJP/certification/Static-Non-Static-Blocks
Sri

[Barkat Mardhani]

Posted by Sri:

There is nothing strange about it.
static {} is called a static initializer
A static initializer block executes only once and this happens even before an instance of the class is created.
i,e even before
TestStatic ts = new TestStatic();
Hope this helps,
Sri

I agree with Sri. But I would add that static initializer is executed when the class is ACCESSED (i.e. an object is created or a static value is accessed). Otherewise static initializer is not executed.

[Anshul Chhabra]

Wouldnt it really depend on the particular JDK policy of loading classes?
From what I understand though, a static initializer block is guaranteed to execute "Before" any access to the class happens. Which means, it could at the latest happen just before the first access of any kind to the class happens.
Though if you had a specific import, like
import com.blah.blah.blahclass;
,wouldnt this specific import cause the static initializers to be loaded?

[Jose Botella]

These are the three phases a class undergoes before it can be used:
a) Load. The exact time a class is loaded into the JVM depends on the implementation of it. An early strategy could load the classes as they appear in the source code and those classes that are referred to by them. Also it is possible to load the classes in related groups. A common strategy is load the classes due to the first appearance of the name of the class in the text.
b) Linking.
b1) Verification of the bytecodes, compliance with the format of the class file and much more.
b2) Preparation. The static variables are assigned space in the static data area. They are initialized to its default values (0, null)
b3) Resolution. The symbolic references in the constant pool are replaced by direct ones. It is optional until the first use of the reference.
c) Intialization. The static variables receive the values specified by the programmer. That is, the static initializers and static variable intitializers are executed (in order of appearance).
The exact time the intialization happens is not a subject for the exam. However...
A class is initialized because of the first active use of it.
Active uses of a class are:
The creation of an instance of it.
An access to one of its static members.
The initialization of a subclass.
[ February 19, 2003: Message edited by: Jose Botella ]

[Gurucharan Murudeshwar]

Hello All,
Generally, we use the static methods by saying
someObj.thatStaticMethod();
But here, the instantiation itself triggers the println line.
Can someone explain the need o such a functionality ?
Cheers,
gurucharan

[Garrett Smith]

Maybe if you wanted to initialize a collection.

public interface SqlBundle {
    final ResourceBundle SQL = ResourceBundle.getBundle("db");
    public static final Map props = new HashMap();
    
    static {
    props.put("INITIAL_CONNECTIONS", new Integer(SQL.getString("INITIAL_CONNECTIONS")));
    }

This would allow for some preliminary initialization from a properties file.

[John Paverd]

Originally posted by Gurucharan Murudeshwar:
Hello All,
Generally, we use the static methods by saying
someObj.thatStaticMethod();
But here, the instantiation itself triggers the println line.

When you type "java TestStatic" on the command line, the JVM will load the TestStatic class and will execute the static main method: TestStatic.main(args). It is this that causes the static initializer to be executed, not the instantiation of an instance of TestStatic. This can be verified by adding some printlns to the code:

public class TestStatic {
   
   static {
      System.out.println("This is strange !!!");
   }
   
   public static void main(String args[]) {
      System.out.println("Before instantiation");
      TestStatic ts = new TestStatic();
      System.out.println("After instantiation");
      
   }
   
}
  

The output is:
This is strange !!!
Before instantiation
After instantiation

[Jose Botella]

Good point John
Onther active use of a class is its designation as the "principal" for an aplication, that is holding the main method.

[Jose Botella]

Generally, we use the static methods by saying
someObj.thatStaticMethod();
But here, the instantiation itself triggers the println line.
Can someone explain the need o such a functionality?

Do not confuse the static methods with the static initializers of the form
static {....}
or with the static variable initializers like this
static field int = 4;
The compiler gathers the code of all the static initializers and all the static variable intializers in textual order and places them in the class initialization method (*) . This method is executed, upon the first active use of the class, to provide for the initialization of the static fields that are not constants with a known value at compile time. Fields that are constant with a value known at compile time see their occurances in the text program replaced with the proper value itself by the compiler. After all they are not going to change. Are they?
Anyway coming back to the question. A static initializer is necessary instead of a static variable initializer in the cases the initialization code does not fit in a single sentence. For instance, if some exception handling is needed put the try/catch clauses within a static initializer.
(*) use javap -c MyClass to check this