When private keyword is assigned to a method, then that method cannot be access by other outside class, this way we can add security to those methods. Since Constructors are also like methods in Java, we can make the Constructor as private. Object for the class can only be created internally within the class, no outside class can create object for this class if constructor is private. Using this we can restrict the caller from creating objects.

Some of the uses of private constructors:

  • Singleton Design Pattern
  • Limit number of instance creation
  • Static Utility Class
  • Prevent Subclassing
  • Builder Design Pattern

Singleton Design Pattern

A class is said to be singleton if it limits the number of objects of that class to one. We can’t have more than a single object for such classes. Singleton classes are employed extensively in concepts like Networking and Database Connectivity.

// Singleton pattern using private constructors.
class SingletonExample { 

	static SingletonExample instance = null; 
	public int x = 10; 
	// private constructor can't be accessed outside the class 
	private SingletonExample() { } 

	// Factory method to provide the users with instances 
	static public SingletonExample getInstance() 
		if (instance == null) {
      instance = new SingletonExample(); 

		return instance; 

class Main{ 

  public static void main(String args[]){ 
    SingletonExample a = SingletonExample.getInstance(); 
    a.x = a.x + 10;


Limit number of instance creation

By making constructor private and then creating a visible constructor method, we can limit the number of instance creations (like we do in singleton design pattern).

class ObjectCreation {

    // Count of alive instances in JVM
    public static int objCount = 0;

    // private constructor
    private ObjectCreation(){
      System.out.println("instance " + objCount + " created");

    // static factory method to return ObjectCreation instance 
    public static synchronized ObjectCreation getLimInstance() {

      if(objCount < 3 ){
          return new ObjectCreation();

      return null;
    // Decreases the objCount static variable when JVM runs garbage collection
    public void finalize() {

      System.out.println("Instance destroyed");

public class LimitObjectCreationTest {

  public static void main(String[] args) {

    ObjectCreation obj;
    int i=1;
      obj = ObjectCreation.getLimInstance();


Static Utility Class

Usefull for scenario when you have a class full of utility functions where instantiating an instance of it makes no semantic sense. Best way to deal with utility class

  • Declare class as final, so that no other class inherit it.
  • Declare its constructor private (no instance creation)
  • Provide public static utility methods


// Final class example
// To avoid extending; classes and methods may be marked as final.
public final class A {
  // Final method
  public final void someMethod() {


JDK implementation of Utility classes are

  • java.util.Arrays
  • java.lang.Math


Prevent Subclassing

We can prevent sublcassing (extending) if we create only a private constructor, no class can extend your class, because it can’t call the super() constructor.

class A {
  // Private constructor
  private A() {

// Compiler will give error
class B extends A {



Builder Design Pattern

Private constructors are also used in Builder Design Pattern and thus creating Immutable classes.