How Private Constructor in Java Enhances Code Efficiency!

A private constructor in Java restricts class instantiation from external sources, ensuring full control over object creation. It is commonly used in Singleton design patterns to maintain a single class instance. 

By making the constructor private, Java enforces strict control over object lifecycle and state management. In Java, private constructors are also crucial for utility classes, ensuring that only static methods are accessible and preventing unnecessary object creation.

In this blog, we will explore the fundamental concepts of private constructors in Java.

What is a Private Constructor in Java? 

A private constructor in Java restricts object creation from outside the class, ensuring that the class is instantiated only under controlled conditions. This is especially useful in design patterns like Singleton, where only one instance of the class is allowed. 

In machine learning, private constructors can be used in utility or configuration classes to ensure the proper management of resources, such as training data or model configurations.  

If you want to learn Java concepts and design patterns, such as the Singleton and Builder patterns, the following upGrad courses can help you succeed. 

• AI-Powered Full Stack Development Course by IIITB
• Future-Proof Your Tech Career with AI-Driven Full-Stack Development
• Professional Certificate Program in Cloud Computing and DevOps

When to Use Private Constructors?

• Utility Classes: Prevent object creation when only static methods are required.
• Singleton Classes: Ensure that only one instance of a class exists.
• Controlled Object Creation: Restrict instantiation within the class itself for specific control.

Code Example: Private Constructor in a Utility Class

Create a utility class that provides static methods for mathematical operations like addition and subtraction. Ensure no objects of the utility class can be created.

java

// Utility class for mathematical operations
class MathUtils {

    // Private constructor to prevent object creation
    private MathUtils() {
        throw new UnsupportedOperationException("Cannot instantiate MathUtils");
    }

    // Static method for addition
    public static int add(int a, int b) {
        return a + b;
    }

    // Static method for subtraction
    public static int subtract(int a, int b) {
        return a - b;
    }
}

public class Main {
    public static void main(String[] args) {
        // Accessing static methods without creating an object
        int sum = MathUtils.add(7, 3);
        int difference = MathUtils.subtract(10, 4);

        // Output the results
        System.out.println("Sum: " + sum);
        System.out.println("Difference: " + difference);

        // Uncomment the following code to see the error
        // MathUtils utils = new MathUtils();
    }
}

Output

Sum: 10
Difference: 6

Steps to Run the Code

1. Copy the code into a Java IDE or text editor.

2. Save the file as Main.java (or use the appropriate class name if you change it).

3. Compile the file using javac Main.java.

4. Run the program using java Main.

Explanation

1. Private Constructor: The constructor in MathUtils is declared private, ensuring that no class object can be created.
2. Static Methods: The class contains only static methods for mathematical operations, which can be accessed directly using the class name.
3. Error Prevention: Uncommenting the line MathUtils utils = new MathUtils(); would result in a compile-time error, as the constructor is private.

Also read: Scanner Class in Java: Types of Constructors & Methods, How to Use [With Examples]

To fully understand the purpose of private constructors in Java, let’s explore how they contribute to efficient and controlled object creation.

Purpose of Private Constructors in Java

A private constructor in Java restricts class instantiation from external classes, allowing developers to enforce design constraints and object lifecycle control. It plays a key role in encapsulating object creation logic, especially in architectural patterns and utility class design.

• Restricts Instantiation in Utility Classes: Prevents object creation in classes like MathUtils or StringUtils, which provide only static methods in frameworks like Node.js.
• Supports Singleton Implementations: Ensures a single class instance across the application lifecycle, often used for global config managers in backend environments like Spring Boot or Express.js.
• Encourages Encapsulation in Design Patterns: Enables precise control over object construction in patterns like the Factory or Builder, improving consistency and reducing errors in large-scale Vue.js applications.
• Improves Maintainability in Modular Codebases: By isolating object instantiation, developers can refactor or extend components (e.g., service classes in Angular or ReactJS) without breaking external dependencies.
• Used in Static Data Holders and Constants Classes: Applies to classes storing immutable configurations or constants, standard in database config utilities or environment-specific setup scripts in Next.js projects.

Also read: 35 Essential Spring Boot Annotations for Faster Development

Let’s understand the key rules that govern how and when to use a private constructor in Java effectively.

Rules for Private Constructors in Java 

Private constructor in Java are powerful tools for controlling how and when a class is instantiated. They follow specific rules to ensure restricted access and proper use in certain scenarios like design patterns and utility classes.

1. Singleton Pattern

The Singleton pattern ensures that a class has only one instance throughout the application. It is particularly useful for managing shared resources like database connections, configuration settings, or logging.

A private constructor ensures that no external class can create additional instances. Instead, a static method is provided to return the sole instance. The class also typically includes lazy or eager initialization to ensure efficient resource use.

Code:

Create a Logger class to handle logging throughout the application, ensuring only one instance exists for centralized logging.

java

// Singleton Logger class implementation
class Logger {
    private static Logger instance;

    // Private constructor to prevent direct instantiation
    private Logger() {
        System.out.println("Logger Instance Created");
    }

    // Static method to return the single instance
    public static Logger getInstance() {
        if (instance == null) {
            instance = new Logger();
        }
        return instance;
    }

    // Method to log messages
    public void log(String message) {
        System.out.println("Log: " + message);
    }
}

public class Main {
    public static void main(String[] args) {
        // Accessing the Singleton Logger instance
        Logger logger1 = Logger.getInstance();
        Logger logger2 = Logger.getInstance();

        // Logging messages
        logger1.log("Starting the application...");
        logger2.log("Loading resources...");

        // Verifying that both references point to the same instance
        System.out.println(logger1 == logger2); // true
    }
}

Output

Logger Instance Created
Log: Starting the application...
Log: Loading resources...
true

Explanation

1. Private Constructor:
   • Prevents external instantiation, ensuring only one instance exists.
2. Static Method (getInstance):
   • Creates the instance if it doesn’t exist and returns the same instance for every call.
3. Shared Access:
   • logger1 and logger2 refer to the same instance, demonstrated by logger1 == logger2.
4. Real-World Use Case:
   • In large applications, a singleton logger ensures consistent and centralized logging of application events without creating multiple logger instances.

2. Utility Classes

Utility classes provide reusable static methods or constants (e.g., Math, Collections). These classes do not require instantiation. A private constructor enforces this by preventing object creation, signaling that the class is purely functional.

Code:

Problem Statement:
Create a utility class to provide mathematical operations without allowing object instantiation.

java

// Utility class with static methods
class MathUtils {
    // Private constructor to prevent instantiation
    private MathUtils() {
        throw new UnsupportedOperationException("Cannot instantiate MathUtils");
    }

    public static int add(int a, int b) {
        return a + b;
    }

    public static int subtract(int a, int b) {
        return a - b;
    }
}

public class Main {
    public static void main(String[] args) {
        // Using static methods directly
        System.out.println("Sum: " + MathUtils.add(5, 3));
        System.out.println("Difference: " + MathUtils.subtract(10, 4));

        // Uncommenting this line will cause a compile-time error
        // MathUtils utils = new MathUtils();
    }
}

Output:

Sum: 8
Difference: 6

Explanation:
The private constructor prevents object creation. Attempting to instantiate the class results in an exception, while static methods remain accessible.

3. Factory Method Pattern

In the Factory design pattern pattern, object creation is controlled via factory methods, which return instances of a class. The constructor is private to restrict direct instantiation. This allows flexibility in modifying object creation logic without changing external code.

Code:

Problem Statement:
Implement a factory method for creating products with predefined configurations.

java

class Product {
    private String name;

    // Private constructor to restrict object creation
    private Product(String name) {
        this.name = name;
    }

    // Factory methods
    public static Product createLaptop() {
        return new Product("Laptop");
    }

    public static Product createPhone() {
        return new Product("Phone");
    }

    public String getName() {
        return name;
    }
}

public class Main {
    public static void main(String[] args) {
        // Creating objects using factory methods
        Product laptop = Product.createLaptop();
        Product phone = Product.createPhone();

        System.out.println("Product 1: " + laptop.getName());
        System.out.println("Product 2: " + phone.getName());
    }
}

Output:

Product 1: Laptop
Product 2: Phone

Explanation:
The factory methods (createLaptop, createPhone) control how objects are created, and external classes cannot directly instantiate the Product class.

4. Preventing Subclassing

A private constructor in java prevents inheritance by ensuring that no subclass can call the parent class constructor. This is useful for creating immutable classes or enforcing specific behaviors in the class hierarchy.

Code:

Problem Statement:
Create a class that cannot be subclassed to ensure immutability.

java

final class ImmutableClass {
    private ImmutableClass() {
        System.out.println("This class cannot be subclassed");
    }

    public static ImmutableClass createInstance() {
        return new ImmutableClass();
    }
}

// Uncommenting this will cause a compile-time error
// class SubClass extends ImmutableClass {}

public class Main {
    public static void main(String[] args) {
        ImmutableClass obj = ImmutableClass.createInstance();
    }
}

Output:

This class cannot be subclassed

Explanation:
The private constructor ensures that no other class can extend ImmutableClass, preserving its immutability and behavior.

5. Uninstantiable Classes

Classes meant for storing constants or grouping static methods do not need instances. A private constructor prevents unnecessary instantiation, making the class clear in its intent.

Code:

Problem Statement:
Create a class to store application-wide constants without allowing object creation.

java

class AppConstants {
    // Private constructor to prevent instantiation
    private AppConstants() {
        throw new UnsupportedOperationException("Cannot instantiate AppConstants");
    }

    public static final String APP_NAME = "MyApplication";
    public static final int VERSION = 1;
}

public class Main {
    public static void main(String[] args) {
        System.out.println("App Name: " + AppConstants.APP_NAME);
        System.out.println("Version: " + AppConstants.VERSION);
    }
}

Output:

App Name: MyApplication
Version: 1

Explanation:
The private constructor ensures that the class serves its intended purpose of storing constants and cannot be instantiated.

Also read: Constructor Overloading in Java: Explanation, Benefits & Examples

Let’s now explore how implementing a private constructor in the Singleton pattern ensures controlled, single-instance object creation.

Implementing a Private Constructor in a Singleton Class

A private constructor in Java is essential when implementing the Singleton design pattern to ensure restricted, one-time object creation across the application. This pattern is common in backend configuration managers and frontend build tools where central control is required, like in JavaScript bundlers or HTML renderers.

Step 1: Declare a Static Instance Variable: Use a private static reference that holds the only instance, shared across the class globally.

Step 2: Define a Private Constructor: Prevent external instantiation and enforce controlled access, just like restricting direct access to CSS utility classes.

Step 3: Create a Public Static getInstance() Method: Check if the instance exists and return it. If not, create it using lazy initialization.

Step 4: Use the Singleton Object Across Modules: This object can coordinate configuration for logging, DB access, or UI themes like ReactJS or VueJS themes.

Step 5: Maintain Shared State Across Calls: Changes made to the singleton instance persist across calls, useful in server-side NodeJS or client-side browser apps.

Code Example:

class Logger {
    private static Logger instance;
    public String source;

    private Logger() {
        System.out.println("Logger created for UPI transaction logs.");
        source = "NPCI-India";
    }

    public static Logger getInstance() {
        if (instance == null) {
            instance = new Logger();
        }
        return instance;
    }

    public void log(String message) {
        System.out.println("[Source: " + source + "] Log: " + message);
    }
}

public class Main {
    public static void main(String[] args) {
        Logger logger1 = Logger.getInstance();
        Logger logger2 = Logger.getInstance();

        logger1.log("Payment initiated via BHIM App.");
        logger2.log("Transaction processed for ₹750 using QR code.");
        System.out.println(logger1 == logger2);
    }
}

Output:

Logger created for UPI transaction logs.
[Source: NPCI-India] Log: Payment initiated via BHIM App.
[Source: NPCI-India] Log: Transaction processed for ₹750 using QR code.
true

Code Explanation:

This example ensures consistent logging using a singleton design pattern with a private constructor in Java. Both logger references point to the same instance, maintaining state across method calls.

If you want to gain expertise in ReactJS for advanced Java functions, check out upGrad’s React.js for Beginners. The 14-hour free program will help you learn React components, analytical skills, routing, and more for enterprise-grade applications. 

To understand how private constructors ensure non-instantiability, let’s examine their role in utility classes.

upGrad’s Exclusive Software and Tech Webinar for you –

SAAS Business – What is So Different?

Implementing a Private Constructor for Utility Classes 

The private constructor in Java is essential in the Builder pattern, allowing controlled object creation through an inner builder class. It’s widely used in fields, such as form builders in Flask apps, ETL pipeline configurations in Apache Spark, or model configurations in Scala-based systems.

Here are some of the factors why you should consider a Private Constructor in the Builder Pattern:

• Object Construction Logic: The private constructor ensures that only the builder class can instantiate the object, enforcing structure and consistency across large modular systems.
• Enables Flexible Object Creation: Supports building objects with only required fields without overloading constructors, ideal for layered APIs and configuration-heavy environments like Apache Spark.
• Improves Code Maintainability: The builder logic is decoupled from the core class, making it easier to read and modify, especially in enterprise-scale Java or Scala applications.
• Supports Method Chaining for Readability: Each setter returns the builder instance, promoting chainable calls that reduce boilerplate code, as seen in UI form builders or object mappers.
• Works with Immutable Objects: Often paired with final fields to ensure thread-safe and immutable object construction, a common requirement in Flask-like REST API configurations.

Code Example:

public class Employee {
    // Final fields to support immutability
    private final String name;
    private final int age;
    private final String department;

    // Private constructor prevents direct instantiation
    private Employee(String name, int age, String department) {
        this.name = name;
        this.age = age;
        this.department = department;
    }

    // Static inner Builder class
    public static class Builder {
        private String name;
        private int age;
        private String department;

        public Builder setName(String name) {
            this.name = name;
            return this;
        }

        public Builder setAge(int age) {
            this.age = age;
            return this;
        }

        public Builder setDepartment(String department) {
            this.department = department;
            return this;
        }

        public Employee build() {
            return new Employee(name, age, department);
        }
    }

    @Override
    public String toString() {
        return "Employee{name='" + name + "', age=" + age + ", department='" + department + "'}";
    }

    public static void main(String[] args) {
        // Create an Employee object with all fields
        Employee emp1 = new Employee.Builder()
            .setName("Rahul Mehra")
            .setAge(32)
            .setDepartment("Data Engineering")
            .build();

        // Create another Employee with partial fields
        Employee emp2 = new Employee.Builder()
            .setName("Ananya Sharma")
            .setDepartment("HR")
            .build();

        System.out.println(emp1);
        System.out.println(emp2);
    }
}

Output:

Employee{name='Rahul Mehra', age=32, department='Data Engineering'}
Employee{name='Ananya Sharma', age=0, department='HR'}

Code Explanation:

The private constructor restricts object creation to the builder, ensuring controlled and structured instantiation. This pattern enhances flexibility and clarity, particularly in applications that involve multiple optional parameters.

Also read: 50 Java Projects With Source Code in 2025: From Beginner to Advanced

To better understand object creation, let’s explore how private constructors in the Builder pattern offer control and flexibility.

Using Private Constructors in the Builder Pattern

The private constructor in Java is crucial for the Builder pattern, ensuring controlled object creation through an inner builder class. This approach is common in cloud-based services like AWS Lambda or Azure, requiring flexible, immutable object construction.

• Control Object Creation: The private constructor ensures that object creation is only possible through the Builder, ensuring consistency.
• Flexible Object Construction: The Builder allows creating objects with only the necessary fields, ideal for cloud-based applications and scalable services.
• Improves Code Maintainability: The Builder pattern decouples object creation logic, making the code more transparent and easier to maintain in distributed systems.
• Prevents Constructor Overload: It avoids multiple constructors by providing a single method for object creation, simplifying large-scale system development.
• Supports Immutable and Thread-Safe Design: The Builder ensures that objects are immutable and thread-safe, vital for concurrent systems in cloud platforms like AWS.

Code Example: 

public class Employee {
    // Final fields ensure immutability
    private final String name;
    private final int age;
    private final String department;

    // Private constructor to restrict direct instantiation
    private Employee(String name, int age, String department) {
        this.name = name;
        this.age = age;
        this.department = department;
    }

    // Static inner Builder class
    public static class Builder {
        private String name;
        private int age;
        private String department;

        public Builder setName(String name) {
            this.name = name;
            return this;
        }

        public Builder setAge(int age) {
            this.age = age;
            return this;
        }

        public Builder setDepartment(String department) {
            this.department = department;
            return this;
        }

        // Build method to return the Employee object
        public Employee build() {
            return new Employee(name, age, department);
        }
    }

    @Override
    public String toString() {
        return "Employee{name='" + name + "', age=" + age + ", department='" + department + "'}";
    }

    public static void main(String[] args) {
        // Create an Employee object with all fields
        Employee emp1 = new Employee.Builder()
            .setName("Ravi Kumar")
            .setAge(28)
            .setDepartment("Cloud Engineering")
            .build();

        // Create another Employee with partial fields
        Employee emp2 = new Employee.Builder()
            .setName("Priya Verma")
            .setDepartment("Data Science")
            .build();

        System.out.println(emp1);
        System.out.println(emp2);
    }
}

Output:

Employee{name='Ravi Kumar', age=28, department='Cloud Engineering'}
Employee{name='Priya Verma', age=0, department='Data Science'}

Code Explanation:

The private constructor ensures that only the Builder can create instances, enabling flexible and consistent object construction. This pattern is particularly effective for building scalable cloud applications like AWS Lambda and Azure-based services.

Why Choose upGrad for Learning Java Functions?

A private constructor in Java is a critical tool for managing object instantiation and enforcing design patterns, such as the Singleton pattern. To use private constructors effectively, focus on understanding their role in controlling object lifecycle and system integrity. 

Many developers struggle with managing scalable application design, especially when avoiding unwanted object creation becomes critical. upGrad’s additional courses can help you build the expertise needed to master these design techniques.

• Generative AI Mastery Certificate for Software Development
• Core Java Basics
• JavaScript Basics from Scratch

Curious which courses can enhance your Java skills and design pattern expertise? Contact upGrad for personalized counseling and valuable insights. For more details, you can also visit your nearest upGrad offline center.

Boost your career with our popular Software Engineering courses, offering hands-on training and expert guidance to turn you into a skilled software developer.

Explore our Popular Software Engineering Courses

Master in-demand Software Development skills like coding, system design, DevOps, and agile methodologies to excel in today’s competitive tech industry.

In-Demand Software Development Skills

Stay informed with our widely-read Software Development articles, covering everything from coding techniques to the latest advancements in software engineering.

Read our Popular Articles related to Software

Reference Link:
https://www.upgrad.com/tutorials/software-engineering/java-tutorial/java-classes-and-objects/