How is deferred initialization of objects or components implemented in software systems?

Lazy initialization is a technique where an object or component is not created immediately when the program loads, but only at the moment of the first access to it. This helps save resources and speeds up the application startup.

In Java, lazy initialization can be implemented in several ways:

1. Using lazy loading with null check:

public class MyClass {
    private ExpensiveObject obj;

    public ExpensiveObject getObj() {
        if (obj == null) {
            obj = new ExpensiveObject();
        }
        return obj;
    }
}

2. Using the volatile keyword and double-checked locking for thread safety:

public class MyClass {
    private volatile ExpensiveObject obj;

    public ExpensiveObject getObj() {
        if (obj == null) {
            synchronized(this) {
                if (obj == null) {
                    obj = new ExpensiveObject();
                }
            }
        }
        return obj;
    }
}

3. Using the Lazy<T> class from third-party libraries or custom implementations.

4. Initialization via an internal static class (Initialization-on-demand holder idiom):

public class MyClass {
    private static class Holder {
        static final ExpensiveObject INSTANCE = new ExpensiveObject();
    }

    public static ExpensiveObject getInstance() {
        return Holder.INSTANCE;
    }
}

This method guarantees thread safety and lazy initialization without synchronization.

Lazy initialization is useful when creating an object is costly, and it may not be needed during the program's execution.