why static block in child class does not get executed?

Question

here is the code

public class ClassResolution {
static class Parent {
    public static String name;
    static {
        System.out.println(\"this is Parent         


        

Answer 1

From JLS 12.4.1:

A class or interface type T will be initialized immediately before the first occurrence of any one of the following:

• T is a class and an instance of T is created.
• T is a class and a static method declared by T is invoked.
• A static field declared by T is assigned.
• A static field declared by T is used and the field is not a constant variable (§4.12.4).
• T is a top-level class, and an assert statement (§14.10) lexically nested within T is executed.

As you can see, nothing of these happens in your code (note that name is declared in Parent, not in Child), therefore Child doesn't get initialized and its static block doesn't get executed.

If you do something to trigger initialization of Child, you'll get an expected output:

new Child();
System.out.println(Child.name); 

Note, however, that static fields are not inherited, therefore Child.name and Parent.name actually refer to the same field. That's why it doesn't make much sense to use code similar to your example in practice.

Also note that despite the fact that Child.name actually refers to Parent.name, it's still referenced as Child.name in the bytecode, therefore your code triggers loading of Child, but not its initialization.

Answer 2

As Child.name is really Parent.name, Child is not needed.

You might find this interesting.

public class ClassResolution {
    static class Parent {
        public static String name;

        static {
            System.out.println("this is Parent");
            name = "Parent";
        }

    }

    static class Child extends Parent {
        static {
            System.out.println("this is Child");
            name = "Child";
        }

        static String word ="hello";
    }

    public static void main(String[] args) {
        System.out.println(Child.name);
        System.out.println(Child.word);
        System.out.println(Child.name);
    }
}

prints

this is Parent
Parent
this is Child
hello
Child

The javap for this class prints that the references to Child are retained.

C:\>javap -c -classpath . ClassResolution
Compiled from "ClassResolution.java"
public class ClassResolution {
  public ClassResolution();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: getstatic     #3                  // Field ClassResolution$Child.name:Ljava/lang/String;
       6: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       9: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
      12: getstatic     #5                  // Field ClassResolution$Child.word:Ljava/lang/String;
      15: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      18: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
      21: getstatic     #3                  // Field ClassResolution$Child.name:Ljava/lang/String;
      24: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      27: return
}

Answer 3

JLS#12.4.1. When Initialization Occurs

A reference to a static field (§8.3.1.1) causes initialization of only the class or interface that actually declares it, even though it might be referred to through the name of a subclass, a subinterface, or a class that implements an interface.

I guess above says it all..

Answer 4

Oops, I was wrong, the reference to Child was not removed and the class was really loaded, but not initialized. Congratulations, you have found a JVM bug. Go to Oracle site and file it. Let me know if you don't want to do so, I'll do it myself.

EDIT: I was wrong again, see comment below. This is not a bug, this is a "gotcha".

Answer 5

In short, Child.name is equal to Parent.name, and the compiler compiles it like so.

Because name is a static field of the Parent class, it is a class method in Parent, not Child. The Java compiler allows a shortcut where child classes can call static parent class methods/fields as if they come from their own class, but internally they are compiled with regards to the parent class.

Although your code refers to Child.name, it is internally Parent.name, as handled by the compiler. Then, because the Child class isn't initialized, the <clinit> static initializer block is never run, and name remains "Parent".