Private Constructor in JAVA
Tags: java, programming, tutorial, productivity
Published: 2022-04-11 12:44:03

In **JAVA** the _constructor_ is a special type of method that has the same name as the class name or file name.
And when we call an object then internally _constructor_ always called, basically it is use to initialize the state of object or the variables values in the class.

**Now Let's see what is private constructors**

JAVA allows us to modify the methods based on the our use.
<u>_So can we make constructor as a private like other methods? and if YES! then what is the use of private constructor?._</u>
Let's check it out!!


So the answer is yes we can declare a constructor in java as a private constructor by using private access specifier. And the most important thing comes into picture that if we declare a constructor as a private then we are not able to create an object of the class. Instead we can use this private constructor in [Singleton Design Pattern](https://www.javatpoint.com/singleton-design-pattern-in-java).

_Let's Check it out the_ **_Rules for Private Constructors_**

- It doesn't allow a class to be sub-classed
- It doesn't allow to create an object outside the class
- If a class has a private constructor and when we try to extend the class, a compile-time error occurs.
- We cannot access a private constructor from any other class.
- If all the constant methods are there in our class, we can use a private constructor.
- If all the methods are static then we can use a private constructor.
- We can use a public function to call the private constructor if an object is not initialized.
- We can return only the instance of that object if an object is already initialized.


```JAVA
public class PrivateConstructorDemo   
{  
     //creating an instance variable of the class Tester  
     private static PrivateConstructorDemo pcd;  
     //creating a private constructor  
     private PrivateConstructorDemo()  
     {  
     }  
    //creating a static method named getInstance()  
    public static PrivateConstructorDemo getInstance()  
    {  
       if(pcd == null)  
       {  
        //creating a constructor of the class      
        pcd = new PrivateConstructorDemo();  
       }  
     return pcd;  
    }  
    //main() method  
    public static void main(String args[])   
    {  
     PrivateConstructorDemo pcd = PrivateConstructorDemo.getInstance();  
    PrivateConstructorDemo pcd1 = PrivateConstructorDemo.getInstance();  
    //invokes the getInstance() method and prints the corresponding result  
    System.out.println(pcd.equals(pcd1));  
   }    
}  
```
output

```
true
```

Let's see the Use Cases of Private Contractors

The main purpose of using a private constructor is to restrict object creation. We also use private constructors to implement the [Singleton design pattern](https://www.geeksforgeeks.org/singleton-design-pattern/). The use-cases of the private constructor are as follows:

- It can be used with static members-only classes.
- It can be used with static utility or constant classes.
- It can also be used to create singleton classes.
- It can be used to assign a name, for instance, creation by utilizing factory methods.
- It is also used to avoid sub-classing.
- It incorporates the factory methods.

Now it's time for you to explore more about the JAVA constructors.