When is a static nested class (and static members therein) loaded into memory?

Question

Here, I was trying to implement a singleton class for my Database connectivity using the inner static helper class :

package com.myapp.modellayer;

public class DatabaseConnection {

    private DatabaseConnection() {
        //JDBC code...
    }

    private static class ConnectionHelper {
        // Instantiating the outer class
        private static final DatabaseConnection INSTANCE = new DatabaseConnection();
    }

    public static DatabaseConnection getInstance() {
        return ConnectionHelper.INSTANCE;
    }
}

However, my doubt is when does this static inner class, ConnectionHelper, gets loaded in to the JVM memory:

At time when DatabaseConnection class gets loaded, or At a time when getInstance() method is called ?

Garry

Note that static in static class does not have the same meaning as static in a member declaration in Java. It simply means it is a nested non-inner class. – Neutralism

@Neutralism BTW the answer there is just as wrong as 99.9% of all others on the subject. There is actually such a thing as an inner class without an enclosing instance. (See here, for example). – Dubuffet

There is nothing particularly special about static nested classes. They are loaded the same way as non static and/or non nested classes. To the JVM, all classes are the same and it doesn't really understand nesting the way Java does. – Photoelasticity

Answer 1

When the class gets loaded is just an implementation detail; you want to know when the class is initialized. It will get initialized only when it is first needed, and that is when you call getInstance().

You are BTW using the lazy initialization holder class idiom which is based on exactly this guarantee by the Java Language Specification. As Josh Bloch said,

This idiom is almost magical. There's synchronization going on, but it's invisible. The Java Runtime Environment does it for you, behind the scenes. And many VMs actually patch the code to eliminate the synchronization once it's no longer necessary, so this idiom is extremely fast.

Dubuffet

I read about this thread safety mechanism being widely used in Singleton design pattern somewhere, but wasn't sure about the loading of the classes – Garry

Answer 2

The oracle doc page says:

Note: A static nested class interacts with the instance members of its outer class (and other classes) just like any other top-level class. In effect, a static nested class is behaviorally a top-level class that has been nested in another top-level class for packaging convenience.

You it is loaded the same way other classes are loaded.

Christadelphian

This must be the accepted answer to the question, because it explains exactly what the user has asked. The accepted answer is not even relevant to the question. – Perforated

@RakeshYadav yes agree – Christadelphian