Private Constructor

A private constructor is an instance initialization method restricted by the private access modifier, preventing the class from being instantiated from outside its own enclosing scope. By explicitly declaring a constructor as private, you instruct the Java compiler to deny any external class from invoking the new keyword on that specific constructor.

public class RestrictedClass {
    
    // Private constructor declaration
    private RestrictedClass() {
        // Initialization logic
    }
}

Technical Mechanics

1. Suppression of the Default Constructor According to the Java Language Specification (JLS §8.8.9), if a Java class contains no explicit constructor declarations, the compiler automatically generates a no-argument default constructor that takes on the same access modifier as the class itself (e.g., public if the class is public, or package-private if omitted). Defining an explicit private constructor overrides this behavior, ensuring no implicit default constructor is generated.

2. Internal Invocation While external instantiation is blocked, the private constructor remains fully accessible to members within the same enclosing scope. It can be invoked by:

• Static methods within the class.
• Static variable initializers.
• Instance methods within the class.
• Instance variable initializers.
• Other constructors within the same class (using this()).

public class InternalInstantiator {
    private int value;

    // Private constructor
    private InternalInstantiator(int value) {
        this.value = value;
    }

    // Static method invoking the private constructor
    public static InternalInstantiator createInstance() {
        return new InternalInstantiator(42); // Valid internal invocation
    }
    
    // Instance method invoking the private constructor
    public InternalInstantiator createCopy() {
        return new InternalInstantiator(this.value); // Valid internal invocation
    }
}

class ExternalClass {
    public void attemptInstantiation() {
        // new InternalInstantiator(10); // COMPILE ERROR: has private access
        InternalInstantiator instance = InternalInstantiator.createInstance(); // Valid
    }
}

3. Inheritance Restrictions and Nested Classes During subclass instantiation, the Java compiler mandates a call to a superclass constructor (either implicitly, or explicitly via super()). If a class defines only private constructors, it cannot be subclassed by any class outside of its own enclosing scope, because the external subclass cannot resolve the private superclass constructor.

However, a class with only private constructors can be subclassed by a nested or inner class defined within the same enclosing scope. Because nested classes share access to all private members of their enclosing class, they can successfully invoke a private super() constructor.

public class BaseClass {
    
    private BaseClass() {
    }

    // VALID: Nested class shares the enclosing scope and can access private members
    public static class NestedSubClass extends BaseClass {
        public NestedSubClass() {
            super(); // Successfully resolves the private constructor
        }
    }
}

/*
// COMPILE ERROR: BaseClass() has private access in BaseClass
class ExternalSubClass extends BaseClass {
    public ExternalSubClass() {
        super(); // Cannot access private constructor from outside the enclosing scope
    }
}
*/

4. Constructor Overloading A class can mix private constructors with constructors of other access levels (e.g., public, protected, or package-private). In this scenario, external classes can still instantiate or subclass the class using the accessible constructors, while the private constructor remains strictly for internal delegation.

public class MixedConstructors {
    private String id;
    
    // Private constructor for internal delegation
    private MixedConstructors(String id) {
        this.id = id;
    }

    // Public constructor accessible externally
    public MixedConstructors() {
        this("DEFAULT_ID"); // Delegates to the private constructor
    }
}

5. Reflection Bypass Despite the compiler-enforced access control, a private constructor can be bypassed at runtime using the Java Reflection API. By obtaining the Constructor reference and invoking setAccessible(true), external code can suppress the Java language access checks and instantiate the class. This is a critical security and design consideration when relying on private constructors to enforce strict instantiation limits (such as in Singleton or utility class patterns).

import java.lang.reflect.Constructor;

public class ReflectionBypass {
    public static void bypassPrivateConstructor() throws Exception {
        // Obtain the private constructor
        Constructor<RestrictedClass> constructor = RestrictedClass.class.getDeclaredConstructor();
        
        // Suppress access control checks
        constructor.setAccessible(true); 
        
        // Instantiate the class externally
        RestrictedClass instance = constructor.newInstance(); 
    }
}

Master Java with Deep Grasping Methodology!

Learn More