# Constructor Overloading in Java – A Complete Guide

**Last Updated:** 2026

---

## Introduction

Java is an **Object-Oriented Programming (OOP)** language, and the first step in OOP is **object creation**.  
Whenever an object is created in Java, a **constructor** is automatically called.

In real-world programs, we do not always want to create objects in the same way.  
Sometimes we want to create an object **without data**, sometimes **with partial data**, and sometimes **with full data**.

👉 To handle these different situations, Java provides a feature called **Constructor Overloading**.

---

## What is Constructor Overloading?

**Constructor Overloading** means:

> **Defining more than one constructor in the same class with different parameter lists.**

### Important Points

* Constructor name is always the **same as the class name**
    
* Difference is only in:
    
    * number of parameters
        
    * type of parameters
        
    * order of parameters
        

---

## Why Do We Need Constructor Overloading?

Constructor overloading allows:

* Multiple ways to create an object
    
* Flexibility while initializing objects
    
* Cleaner and more readable code
    

### Example Use Case

* Create an object with default values
    
* Create an object with only name
    
* Create an object with name and id
    

All this is possible using **constructor overloading**.

---

## How Java Chooses the Correct Constructor?

Java decides **at compile time** based on:

1. Number of arguments passed
    
2. Type of arguments
    
3. Order of arguments
    

This is called **compile-time polymorphism**.

---

## Types of Constructor Overloading

Constructor overloading can happen in **three ways**:

1. By changing the **number of parameters**
    
2. By changing the **type of parameters**
    
3. By changing the **order of parameters**
    

Let’s understand each one with examples.

---

## 1️⃣ Constructor Overloading by Number of Parameters

### Example

```plaintext
class Demo {

    Demo() {
        System.out.println("No argument constructor");
    }

    Demo(int a) {
        System.out.println("One argument constructor");
    }

    Demo(int a, int b) {
        System.out.println("Two argument constructor");
    }

    public static void main(String[] args) {
        new Demo();
        new Demo(10);
        new Demo(10, 20);
    }
}
```

### Output

```plaintext
No argument constructor
One argument constructor
Two argument constructor
```

### Explanation

* `Demo()` → 0 parameters
    
* `Demo(10)` → 1 parameter
    
* `Demo(10, 20)` → 2 parameters
    

✔ Different number of parameters → constructor overloading

---

## 2️⃣ Constructor Overloading by Type of Parameters

### Example

```plaintext
class Demo {

    Demo(String name) {
        System.out.println("String constructor: " + name);
    }

    Demo(long id) {
        System.out.println("Long constructor: " + id);
    }

    public static void main(String[] args) {
        new Demo("Amit");
        new Demo(101);
    }
}
```

### Output

```plaintext
String constructor: Amit
Long constructor: 101
```

### Explanation

* Same number of parameters (1)
    
* Different types (`String` and `long`)
    

✔ Different parameter type → constructor overloading

---

## 3️⃣ Constructor Overloading by Order of Parameters

### Example (Tricky but Important)

```plaintext
class Demo {

    Demo(int a, String s) {
        System.out.println("int, String constructor");
    }

    Demo(String s, int a) {
        System.out.println("String, int constructor");
    }

    public static void main(String[] args) {
        new Demo(10, "Hello");
        new Demo("Hello", 10);
    }
}
```

### Output

```plaintext
int, String constructor
String, int constructor
```

### Explanation

* Same parameter types
    
* Same number of parameters
    
* Different order
    

✔ Order difference also causes constructor overloading

---

## Copy Constructor as an Example of Overloading

Although Java does not provide a built-in copy constructor, we can create one manually.

### Example

```plaintext
class Student {

    String name;
    int id;

    Student(String n, int i) {
        name = n;
        id = i;
    }

    // Copy Constructor
    Student(Student s) {
        name = s.name;
        id = s.id;
    }

    public static void main(String[] args) {
        Student s1 = new Student("Rahul", 50);
        Student s2 = new Student(s1);

        System.out.println(s2.name);
        System.out.println(s2.id);
    }
}
```

### Explanation

* One constructor takes `(String, int)`
    
* Another takes `(Student)`
    
* Same class, different parameter list
    

✔ This is constructor overloading

---

## ❌ What is NOT Constructor Overloading?

```plaintext
Demo(int a)
Demo(int b)
```

❌ This is NOT constructor overloading  
Java does **not** care about variable names.  
It only checks:

* number
    
* type
    
* order