Java: Private Constructor

In this article, we will learn and understand the need of private constructor in Java

Private constructor:

Private constructor prevents creating more than one object and also restricts outside classes to instantiate object

Which infers object can be created only from inside of class and to get that object, outside classes invokes static utility method

 

Where it is commonly used or explain scenario?

Private constructor are most commonly used in below scenarios,

  • Classes containing only static utility methods
  • All constants in classes (i.e.; public static final variables)
  • To prevent more than one object creation (Singleton design pattern)
  • To restrict compiler from inserting default no-arg constructor (when there exists no explicit constructor)
  • To utilize factory methods
  • enums for type-safety

 

Points to remember about private constructor

  • Only one object instantiation is possible and that too in same class
  • Therefore, one object of that class is suppose to exist all time
  • Object cannot be created from outside of the class
  • To get that one instance, outside classes needs to invoke static method like getInstance()
  • In multi-threaded environment, multiple objects can be created using same getInsatnce() method
  • But again it can be restricted by adding keyword synchronized to getInstance() method

 

1. Example on private constructor

To demonstrate private constructor example, we will have a simple class making its constructor as private

Static field is declared to store this single instance and to get this instance from outside class we will implement static method which returns singleton instance everytime

 

PrivateConstructorDemo.java

package in.bench.resources.constructor.example;

public class PrivateConstructorDemo {

	// static class reference
	private static PrivateConstructorDemo object = new PrivateConstructorDemo();

	// Prevents other classes from instantiating object of this class
	private PrivateConstructorDemo() {
		// empty private default no-arg constructor
		// Don't let anyone else instantiate this class
	}

	// static utility method to return singleton object
	public static PrivateConstructorDemo getInstance() {
		return object;
	}

	// display demo message
	public void printPrivateConstructorMsg() {
		System.out.println("Private constructor demo: Accessing method using singelton object");
	}
}

 

Here is the test class to invoke and get singleton object (main program)
Finally print message using singleton object

 

TestPrivateConstructor.java

package in.bench.resources.constructor.example;

public class TestPrivateConstructor {

	public static void main(String[] args) {

		PrivateConstructorDemo demo1 = PrivateConstructorDemo.getInstance();
		demo1.printPrivateConstructorMsg();
	}
}

Output:

Private constructor demo: Accessing method using singelton object

 

Explanation:

In above example, we are invoking print() method using object we got from static getInstance() method because direct object creation is not possible

 

2. What happens, if we try to instantiate objects from outside of class?

Compile-time error: The constructor PrivateConstructorDemo() is not visible

Solution: Don’t try to instantiate object of class that contains private constructor rather use static utility method like getInstance() to get singleton instance

 

PrivateConstructorDemo.java

1_Java_Private_Constructor_example

 

TestPrivateConstructor.java

2_Java_Private_Constructor_test_class_for_object_creation_not_possible

 

3. What happens, if we extend the class containing private constructor?

Compile-time error: Implicit super constructor PrivateConstructorDemo() is not visible for default constructor. Must define an explicit constructor

Solution: Don’t try to extend classes containing private constructor. We can get only singleton objects by invoking getInstance() method from this class and then accordingly we can invoke static or non-static utility methods of this class

 

PrivateConstructorDemo.java

1_Java_Private_Constructor_example

 

TestPrivateConstructor.java

3_Java_Private_Constructor_test_class_for_inheritance_not_possible

 

4. Example on Singleton design pattern (Lazy instantiation technique)

Here is the easiest and most commonly used singleton design pattern

This class create object upon demand i.e.; object is not created until and unless we invoke getInstance() method and this technique is known as lazy instantiation

This is done for the very first time and later when we invoke getInstance() –> directly instance is returned, as already instance created and available in the current context

This singleton design pattern ensures only one object is created and available at any given point of time

SingleTonDemo.java

package in.bench.resources.constructor.example;

public class SingleTonDemo {

	// static class reference
	private static SingleTonDemo instance = null;

	// Prevents other classes from instantiating object of this class
	private SingleTonDemo() {
		// empty private default no-arg constructor
		// Don't let anyone else instantiate this class
	}

	// static utility method to return singleton object
	public static SingleTonDemo getInstance() {

		if(instance == null) {
			// lazy initialization technique
			instance = new SingleTonDemo();
		}
		return instance;
	}

	// display demo message
	public void printPrivateConstructorMsg() {
		System.out.println("Lazy initialization technique: Accessing method using singelton instance");
	}
}

 

TestPrivateConstructor.java

Here is the test class to invoke and get singleton object (main program)
Finally print message using singleton object

package in.bench.resources.constructor.example;

public class TestPrivateConstructor {

	public static void main(String[] args) {

		SingleTonDemo demo2 = SingleTonDemo.getInstance();
		demo2.printPrivateConstructorMsg();
	}
}

Output:

Lazy initialization technique: Accessing method using singelton instance

 

Explanation:

Here too, we are invoking print() method using object we got from static getInstance() method because direct object creation is not possible

But instance created only once, when we invoke getInsatnce() for the very first time

 

References:

https://docs.oracle.com/javase/tutorial/java/javaOO/constructors.html

 

Read Also:

Happy Coding !!
Happy Learning !!