What is Constructor Overloading in Java?

Constructor overloading is an important concept in Java that allows a class to have multiple constructors with different parameter lists. It helps initialize objects in different ways depending on the requirement.

This concept is commonly asked in Java interviews and widely used in real-world applications.

What is a Constructor?

A constructor is a special method in Java that:

  • Has the same name as the class

  • Does not have a return type

  • Is automatically called when an object is created

Its main purpose is to initialize object values.

What is Constructor Overloading?

Constructor Overloading occurs when a class contains more than one constructor with the same name but different parameters.

👉 The constructor executed depends on the arguments passed during object creation.

Syntax

class ClassName {

    ClassName() {
        // default constructor
    }

    ClassName(int a) {
        // parameterized constructor
    }

    ClassName(int a, String b) {
        // another constructor
    }
}

Example Program

class Student {

    String name;
    int age;

    // Default constructor
    Student() {
        name = "Unknown";
        age = 0;
    }

    // Parameterized constructor
    Student(String n, int a) {
        name = n;
        age = a;
    }

    void display() {
        System.out.println(name + " " + age);
    }
}

public class Main {
    public static void main(String[] args) {

        Student s1 = new Student();
        Student s2 = new Student("Rahul", 22);

        s1.display();
        s2.display();
    }
}

Output

Unknown 0
Rahul 22

Explanation

  • The class has two constructors.

  • One initializes default values.

  • Another initializes custom values.

  • Java decides which constructor to call based on parameters.

This is an example of compile-time polymorphism.

Advantages of Constructor Overloading

✔ Provides multiple ways to create objects
✔ Improves code flexibility
✔ Enhances readability
✔ Supports object initialization easily
✔ Reduces the need for setter methods

Important Rules

  • Constructor name must match the class name.

  • Constructors must differ in parameter list.

  • Changing only return type is not allowed.

  • Constructors can call each other using this().

Interview Tip

A simple definition:

Constructor overloading is the process of defining multiple constructors in a class with different parameter lists to initialize objects in different ways.

Conclusion

Constructor overloading makes object creation flexible and efficient. It is widely used in real-time Java applications where objects need different initialization options.

🚀 No 1 Java Real Time Projects Online Training in Hyderabad — ashok it

Want to learn Java concepts with real-time project experience and industry-focused training?

Join our job-oriented Java Full Stack training program guided by real time experts.

✔ Core Java & Advanced Java
✔ Spring Boot & REST API Development
✔ Microservices Architecture
✔ Real-Time Industry Projects
✔ Interview Preparation & Placement Assistance

Comments

Post a Comment

Popular posts from this blog

What is Reflection API in Java?

Image
The Reflection API in Java allows a program to inspect and manipulate classes, methods, constructors, fields, and objects at runtime , even if their details are not known during compilation. In simple terms, reflection lets Java analyze and modify its own structure while the program is running . 🔹 Why Reflection API is Used To get class information dynamically Access private fields and methods Create objects at runtime Invoke methods dynamically Used heavily in frameworks like Spring and Hibernate 🔹 Important Classes in Reflection Package Reflection API is available in: java.lang.reflect Common classes: Class Method Field Constructor 🔹 Example of Reflection class Student { private String name = "Rahul"; public void display() { System.out.println("Hello Student"); } } public class Test { public static void main(String[] args) throws Exception { Class<?> cls = Class.forName("Student"); Object obj = cls.get...
Read more

Spring Boot Microservices Development

Spring Boot Microservices Development Spring Boot Microservices Development has become one of the most popular approaches for building modern, scalable, and cloud-ready applications. Instead of creating one large monolithic system, microservices architecture divides applications into smaller, independent services that communicate with each other through APIs. Spring Boot simplifies this process by providing powerful tools and auto-configuration features. What are Microservices? Microservices architecture is a software development approach where an application is built as a collection of small, loosely coupled services. Each service focuses on a specific business functionality and can be developed, deployed, and scaled independently. Key Characteristics Independent deployment Decentralized data management Scalability and flexibility Faster development cycles Technology independence Why Use Spring Boot for Microservices? Spring Boot reduces configuration complexity and allows developers ...
Read more

Recursion & Dynamic Programming

  Recursion and Dynamic Programming are powerful problem-solving techniques widely used in Java programming. These concepts help developers solve complex problems by breaking them into smaller, manageable subproblems. Understanding recursion and dynamic programming is essential for mastering algorithms, improving coding efficiency, and performing well in technical interviews. What is Recursion? Recursion is a programming technique where a method calls itself repeatedly until a specific condition (called the base case) is met. It simplifies problems that can be divided into smaller versions of the same task. Key Components of Recursion: ✅ Base Case – Stops the recursive calls ✅ Recursive Case – The function calls itself with a smaller input Example: Factorial Using Recursion public class FactorialExample { static int factorial(int n) { if (n == 0 || n == 1) return 1; return n * factorial(n - 1); } public static void main(String[] args) { ...
Read more