Why doesn't this statement throw a StackOverflowError?

Question

I just saw this weird piece of code in another question. I thought it would result in a StackOverflowError being thrown, but it doesn't...

public class Node {     private Object one;     private Object two;     public static Node NIL = new Node(Node.NIL, Node.NIL);      public Node(Object one, Object two) {         this.one = one;         this.two = two;     } } 

I thought it was going to thow an exception, because of the Node.NIL referencing itself to build.

I can't figure it out why it does not.

Answer 1

NIL is a static variable. It is initialized one time, when the class is initialized. When it is initialized, a single Node instance is created. The creation of that Node doesn't trigger creation of any other Node instances, so there is not infinite chain of calls. Passing Node.NIL to the constructor call has the same effect as passing null, since Node.NIL is not yet initialized when the constructor is called. Therefore public static Node NIL = new Node(Node.NIL, Node.NIL); is the same as public static Node NIL = new Node(null, null);.

If, on the other hand, NIL was an instance variable (and wasn't passed as an argument to the Node constructor, since the compiler would have prevented you from passing it to the constructor in that case), it would be initialized every time an instance of Node was created, which would create a new Node instance, whose creation would initialize another NIL instance variable, leading to infinite chain of constructor calls that would end in StackOverflowError.

Answer 2

The variable NIL is first given the value null and then initialised once top to bottom. It isn't a function and isn't defined recursively. Any static field you use before it is initialised has the default value and your code is the same as

public static Node {     public static Node NIL;      static {         NIL = new Node(null /*Node.NIL*/, null /*Node.NIL*/);     }      public Node(Object one, Object two) {         // Assign values to fields     } } 

This is no different to writing

NIL = null; // set implicitly NIL = new Node(NIL, NIL); 

If you defined a function or method like this, you would get a StackoverflowException

Node NIL(Node a, Node b) {     return NIL(NIL(a, b), NIL(a, b)); }