Can a constructor in Java be private?

java

singleton

best-practices

code-testing

byAlex Kataev·Jan 31, 2025

Yes, and for a reason! Private constructors restrict a class from being instantiated by other classes. This strategy is a prominent characteristic of Singleton patterns where we allow existence of just a single instance of a class and in utility classes infested with static methods.

public class UtilityClass {
   private UtilityClass() {
       // Freeloader classes stopped at the gate
   }
}

Swift and short, but let's delve into the nitty-gritty of private constructors' various advantages.

Understanding the utility of private constructors

Private constructors are more than secret access doors in the Java world. They help design unyielding and predictable systems within the borders of the Java language.

Singleton pattern: There can be only one!

Singleton patterns utilize private constructors to ensure only one instance of a class is ever created.

public class Singleton {
   private static Singleton onlyInstance;
    
   private Singleton() {
       // Laid an egg, but just a single one!
   }

   public static Singleton getInstance() {
       // Definitely no twins here
       if (onlyInstance == null) {
           onlyInstance = new Singleton();
       }
       return onlyInstance;
   }
}

Utility classes: No ticket, no ride!

Utility classes containing only static methods and constants use private constructors, sidestepping unnecessary instantiation.

public class MathUtils {
   public static final double PI = 3.14159;

   // Behold the math wizard, but you can't be one!
   private MathUtils() {}

   public static double circleArea(double radius) {
       return PI * radius * radius;
   }
}

Factory pattern: The assembly line

Private constructors guide object creation in factories, offering a clear semantic structure that beats simple constructor overloading.

public class ComplexObjectFactory {
   public static ComplexObject createComplexObject(Type type) {
        
       // Drumroll please... And here is your object!
       return new ComplexObject.Builder().withType(type).build();
   }

   private ComplexObject(Type type) {
       // Top secret constructor recipe
   }
}

No subclassing allowed: Keep off the grass!

Private constructors restrict visibility, preventing classes from becoming subclassed, maintaining their finality without explicitly using the final keyword.

Instance control: The puppet master

A private constructor allows granular control over instances, enabling cached instances or recycling of instances, and preventing loose cannons running around with unsupervised instantiation.

Controlled Hotels

The private constructor manages the guest list for object creation:

Singleton Hotel - There's just one room available. All resources cater to this single guest.
Immutable SkyScrapers - Once the tower is built, it doesn't change - thanks to private constructors and factory methods.

Code detectives love it

Private constructors expose the detective in your code, making it transparent:

Sherlock Holmes - Easier bug hunts with fewer instantiation paths.
Dr. Watson - If you stumble upon a private constructor, a special set of rules for instantiation are at play!

Class sanctity: Code monks

Private constructors preserve the life purpose of utility classes, ensuring classes meant for static use continue like so without unwanted instantiation.

Protect your Castles

Using a private constructor that prevents subclassing shields your class hierarchy:

Rock solid walls - Strengthens your class hierarchy, barring others from potentially messing up your code with subclassing.
Guarded secret - Makes sure you don't spill the beans! Your encapsulation remains uncompromised, not disclosing more access than needed.

Issues with the strategy: All that glitters...

However, using private constructors can present certain hurdles:

Accessibility - Striking a balance between restricting access and ensuring the class is useful without direct instantiation.
Code testing - Classes with private constructors may need special techniques to write tests, such as the use of reflections or accessing the constructor.