Introduction

Imagine you're opening a new bank account. Sometimes you want a basic account with just your name, other times you want to specify everything - name, initial deposit, account type, and benefits. Constructor overloading lets you provide multiple ways to create objects, just like having different account opening options!

Constructor overloading means having multiple constructors in the same class with different parameter lists. It provides flexibility in object creation and initialization.

What is Constructor Overloading?

Constructor overloading is a technique where a class can have more than one constructor, each with a different parameter list. The compiler differentiates them based on the number, type, and order of parameters.

Key Benefits:

• ✅ Flexible object creation - different initialization options
• ✅ Default values - provide sensible defaults for missing parameters
• ✅ Code reusability - constructors can call each other using this()
• ✅ Better API design - intuitive object creation for different use cases

Code Explanation with Examples

Example 1: Basic Constructor Overloading

class Student {
// 🎯 ATTRIBUTES
private String name;
private int age;
private String studentId;
private double gpa;
private String major;
private String email;
// 🎯 CONSTRUCTOR 1: Default constructor (no parameters)
public Student() {
this.name = "Unknown";
this.age = 0;
this.studentId = "N/A";
this.gpa = 0.0;
this.major = "Undeclared";
this.email = "[email protected]";
System.out.println("✅ Default constructor called - Student created with default values");
}
// 🎯 CONSTRUCTOR 2: Name and age only
public Student(String name, int age) {
this.name = name;
this.age = age;
this.studentId = "TEMP_" + System.currentTimeMillis();
this.gpa = 0.0;
this.major = "Undeclared";
this.email = name.toLowerCase().replace(" ", ".") + "@university.edu";
System.out.println("✅ Basic constructor called - Student: " + name + ", Age: " + age);
}
// 🎯 CONSTRUCTOR 3: Name, age, and student ID
public Student(String name, int age, String studentId) {
this.name = name;
this.age = age;
this.studentId = studentId;
this.gpa = 0.0;
this.major = "Undeclared";
this.email = name.toLowerCase().replace(" ", ".") + "@university.edu";
System.out.println("✅ ID constructor called - Student: " + name + ", ID: " + studentId);
}
// 🎯 CONSTRUCTOR 4: Full details constructor
public Student(String name, int age, String studentId, double gpa, String major, String email) {
this.name = name;
this.age = age;
this.studentId = studentId;
this.gpa = gpa;
this.major = major;
this.email = email;
System.out.println("✅ Full constructor called - Student: " + name + ", Major: " + major + ", GPA: " + gpa);
}
// 🎯 COPY CONSTRUCTOR: Create a copy of existing student
public Student(Student other) {
this.name = other.name;
this.age = other.age;
this.studentId = other.studentId;
this.gpa = other.gpa;
this.major = other.major;
this.email = other.email;
System.out.println("✅ Copy constructor called - Copied student: " + other.name);
}
// 🎯 DISPLAY METHOD
public void displayInfo() {
System.out.println("\n=== STUDENT INFORMATION ===");
System.out.println("Name: " + name);
System.out.println("Age: " + age);
System.out.println("Student ID: " + studentId);
System.out.println("GPA: " + gpa);
System.out.println("Major: " + major);
System.out.println("Email: " + email);
}
// 🎯 GETTER METHODS
public String getName() { return name; }
public int getAge() { return age; }
public String getStudentId() { return studentId; }
public double getGpa() { return gpa; }
public String getMajor() { return major; }
public String getEmail() { return email; }
}
public class BasicConstructorOverloading {
public static void main(String[] args) {
System.out.println("=== BASIC CONSTRUCTOR OVERLOADING ===");
// 🎯 CREATING STUDENTS USING DIFFERENT CONSTRUCTORS
System.out.println("\n1. DEFAULT CONSTRUCTOR:");
Student student1 = new Student();
student1.displayInfo();
System.out.println("\n2. BASIC CONSTRUCTOR (name, age):");
Student student2 = new Student("Alice Johnson", 20);
student2.displayInfo();
System.out.println("\n3. ID CONSTRUCTOR (name, age, studentId):");
Student student3 = new Student("Bob Smith", 22, "S12345");
student3.displayInfo();
System.out.println("\n4. FULL CONSTRUCTOR (all details):");
Student student4 = new Student("Carol Davis", 21, "S67890", 3.8, "Computer Science", "[email protected]");
student4.displayInfo();
System.out.println("\n5. COPY CONSTRUCTOR:");
Student student5 = new Student(student4);
student5.displayInfo();
// 🎯 DEMONSTRATING FLEXIBILITY
System.out.println("\n6. FLEXIBILITY DEMONSTRATION:");
System.out.println("We can create students with different levels of information:");
System.out.println("- Default: When no information is available");
System.out.println("- Basic: When we only know name and age");
System.out.println("- With ID: When student ID is available");
System.out.println("- Full: When all details are known");
System.out.println("- Copy: When we need a duplicate");
// 🎯 ARRAY OF STUDENTS CREATED WITH DIFFERENT CONSTRUCTORS
System.out.println("\n7. ARRAY OF STUDENTS:");
Student[] students = {
new Student(),
new Student("David Wilson", 19),
new Student("Eva Brown", 23, "S54321"),
new Student("Frank Miller", 20, "S98765", 3.5, "Mathematics", "[email protected]")
};
for (int i = 0; i < students.length; i++) {
System.out.println("\nStudent " + (i + 1) + ":");
students[i].displayInfo();
}
}
}

Output:

=== BASIC CONSTRUCTOR OVERLOADING ===
1. DEFAULT CONSTRUCTOR:
✅ Default constructor called - Student created with default values
=== STUDENT INFORMATION ===
Name: Unknown
Age: 0
Student ID: N/A
GPA: 0.0
Major: Undeclared
Email: [email protected]
2. BASIC CONSTRUCTOR (name, age):
✅ Basic constructor called - Student: Alice Johnson, Age: 20
=== STUDENT INFORMATION ===
Name: Alice Johnson
Age: 20
Student ID: TEMP_1701234567890
GPA: 0.0
Major: Undeclared
Email: [email protected]
3. ID CONSTRUCTOR (name, age, studentId):
✅ ID constructor called - Student: Bob Smith, ID: S12345
=== STUDENT INFORMATION ===
Name: Bob Smith
Age: 22
Student ID: S12345
GPA: 0.0
Major: Undeclared
Email: [email protected]
4. FULL CONSTRUCTOR (all details):
✅ Full constructor called - Student: Carol Davis, Major: Computer Science, GPA: 3.8
=== STUDENT INFORMATION ===
Name: Carol Davis
Age: 21
Student ID: S67890
GPA: 3.8
Major: Computer Science
Email: [email protected]
5. COPY CONSTRUCTOR:
✅ Copy constructor called - Copied student: Carol Davis
=== STUDENT INFORMATION ===
Name: Carol Davis
Age: 21
Student ID: S67890
GPA: 3.8
Major: Computer Science
Email: [email protected]
6. FLEXIBILITY DEMONSTRATION:
We can create students with different levels of information:
- Default: When no information is available
- Basic: When we only know name and age
- With ID: When student ID is available
- Full: When all details are known
- Copy: When we need a duplicate
7. ARRAY OF STUDENTS:
✅ Default constructor called - Student created with default values
✅ Basic constructor called - Student: David Wilson, Age: 19
✅ ID constructor called - Student: Eva Brown, ID: S54321
✅ Full constructor called - Student: Frank Miller, Major: Mathematics, GPA: 3.5
Student 1:
=== STUDENT INFORMATION ===
Name: Unknown
Age: 0
Student ID: N/A
GPA: 0.0
Major: Undeclared
Email: [email protected]
Student 2:
=== STUDENT INFORMATION ===
Name: David Wilson
Age: 19
Student ID: TEMP_1701234567891
GPA: 0.0
Major: Undeclared
Email: [email protected]
Student 3:
=== STUDENT INFORMATION ===
Name: Eva Brown
Age: 23
Student ID: S54321
GPA: 0.0
Major: Undeclared
Email: [email protected]
Student 4:
=== STUDENT INFORMATION ===
Name: Frank Miller
Age: 20
Student ID: S98765
GPA: 3.5
Major: Mathematics
Email: [email protected]

**Example 2: Constructor Chaining with this()

class Book {
// 🎯 ATTRIBUTES
private String title;
private String author;
private String isbn;
private double price;
private int pageCount;
private String publisher;
private int publicationYear;
// 🎯 CONSTRUCTOR 1: Default constructor
public Book() {
this("Unknown Title", "Unknown Author", "N/A", 0.0, 0, "Unknown Publisher", 0);
System.out.println("🔗 Default constructor → chained to full constructor");
}
// 🎯 CONSTRUCTOR 2: Title and author only
public Book(String title, String author) {
this(title, author, generateISBN(), 0.0, 0, "Unknown Publisher", 0);
System.out.println("🔗 Basic constructor → chained to full constructor");
}
// 🎯 CONSTRUCTOR 3: Title, author, and price
public Book(String title, String author, double price) {
this(title, author, generateISBN(), price, 0, "Unknown Publisher", 0);
System.out.println("🔗 Price constructor → chained to full constructor");
}
// 🎯 CONSTRUCTOR 4: Title, author, ISBN, and price
public Book(String title, String author, String isbn, double price) {
this(title, author, isbn, price, 0, "Unknown Publisher", 0);
System.out.println("🔗 ISBN constructor → chained to full constructor");
}
// 🎯 CONSTRUCTOR 5: Full constructor (MASTER CONSTRUCTOR)
public Book(String title, String author, String isbn, double price, 
int pageCount, String publisher, int publicationYear) {
this.title = title;
this.author = author;
this.isbn = isbn;
this.price = price;
this.pageCount = pageCount;
this.publisher = publisher;
this.publicationYear = publicationYear;
System.out.println("🎯 Master constructor called - Book: " + title);
}
// 🎯 PRIVATE HELPER METHOD FOR ISBN GENERATION
private static String generateISBN() {
return "ISBN-" + (int)(Math.random() * 1000000);
}
// 🎯 DISPLAY METHODS
public void displayBasicInfo() {
System.out.println("📚 " + title + " by " + author + " - $" + price);
}
public void displayFullInfo() {
System.out.println("\n=== BOOK DETAILS ===");
System.out.println("Title: " + title);
System.out.println("Author: " + author);
System.out.println("ISBN: " + isbn);
System.out.println("Price: $" + price);
System.out.println("Pages: " + pageCount);
System.out.println("Publisher: " + publisher);
System.out.println("Year: " + (publicationYear == 0 ? "Unknown" : publicationYear));
}
// 🎯 GETTER METHODS
public String getTitle() { return title; }
public String getAuthor() { return author; }
public String getIsbn() { return isbn; }
public double getPrice() { return price; }
public int getPageCount() { return pageCount; }
public String getPublisher() { return publisher; }
public int getPublicationYear() { return publicationYear; }
}
public class ConstructorChaining {
public static void main(String[] args) {
System.out.println("=== CONSTRUCTOR CHAINING WITH this() ===");
// 🎯 DEMONSTRATING CONSTRUCTOR CHAINING
System.out.println("\n1. DEFAULT CONSTRUCTOR (chains to full):");
Book book1 = new Book();
book1.displayFullInfo();
System.out.println("\n2. BASIC CONSTRUCTOR (title, author - chains to full):");
Book book2 = new Book("The Great Gatsby", "F. Scott Fitzgerald");
book2.displayFullInfo();
System.out.println("\n3. PRICE CONSTRUCTOR (title, author, price - chains to full):");
Book book3 = new Book("To Kill a Mockingbird", "Harper Lee", 12.99);
book3.displayFullInfo();
System.out.println("\n4. ISBN CONSTRUCTOR (title, author, isbn, price - chains to full):");
Book book4 = new Book("1984", "George Orwell", "ISBN-123456", 10.50);
book4.displayFullInfo();
System.out.println("\n5. FULL CONSTRUCTOR (all parameters):");
Book book5 = new Book("Pride and Prejudice", "Jane Austen", "ISBN-789012", 
15.75, 432, "Penguin Classics", 1813);
book5.displayFullInfo();
// 🎯 BENEFITS OF CONSTRUCTOR CHAINING
System.out.println("\n6. BENEFITS OF CONSTRUCTOR CHAINING:");
System.out.println("✅ Code Reusability: Common initialization in one place");
System.out.println("✅ Maintainability: Changes only in master constructor");
System.out.println("✅ Consistency: All objects initialized consistently");
System.out.println("✅ Reduced Duplication: No repeated initialization code");
// 🎯 ARRAY DEMONSTRATION
System.out.println("\n7. BOOK COLLECTION:");
Book[] library = {
new Book(),
new Book("The Catcher in the Rye", "J.D. Salinger"),
new Book("The Hobbit", "J.R.R. Tolkien", 14.99),
new Book("Brave New World", "Aldous Huxley", "ISBN-345678", 11.25),
new Book("Moby Dick", "Herman Melville", "ISBN-901234", 18.50, 635, "Vintage", 1851)
};
System.out.println("\n=== LIBRARY CATALOG ===");
for (int i = 0; i < library.length; i++) {
System.out.print((i + 1) + ". ");
library[i].displayBasicInfo();
}
// 🎯 CHAINING VISUALIZATION
System.out.println("\n8. CONSTRUCTOR CHAINING VISUALIZATION:");
System.out.println("Book() → Book(String, String, String, double, int, String, int)");
System.out.println("Book(String, String) → Book(String, String, String, double, int, String, int)");
System.out.println("Book(String, String, double) → Book(String, String, String, double, int, String, int)");
System.out.println("Book(String, String, String, double) → Book(String, String, String, double, int, String, int)");
}
}

Output:

=== CONSTRUCTOR CHAINING WITH this() ===
1. DEFAULT CONSTRUCTOR (chains to full):
🎯 Master constructor called - Book: Unknown Title
🔗 Default constructor → chained to full constructor
=== BOOK DETAILS ===
Title: Unknown Title
Author: Unknown Author
ISBN: N/A
Price: $0.0
Pages: 0
Publisher: Unknown Publisher
Year: Unknown
2. BASIC CONSTRUCTOR (title, author - chains to full):
🎯 Master constructor called - Book: The Great Gatsby
🔗 Basic constructor → chained to full constructor
=== BOOK DETAILS ===
Title: The Great Gatsby
Author: F. Scott Fitzgerald
ISBN: ISBN-784392
Price: $0.0
Pages: 0
Publisher: Unknown Publisher
Year: Unknown
3. PRICE CONSTRUCTOR (title, author, price - chains to full):
🎯 Master constructor called - Book: To Kill a Mockingbird
🔗 Price constructor → chained to full constructor
=== BOOK DETAILS ===
Title: To Kill a Mockingbird
Author: Harper Lee
ISBN: ISBN-451927
Price: $12.99
Pages: 0
Publisher: Unknown Publisher
Year: Unknown
4. ISBN CONSTRUCTOR (title, author, isbn, price - chains to full):
🎯 Master constructor called - Book: 1984
🔗 ISBN constructor → chained to full constructor
=== BOOK DETAILS ===
Title: 1984
Author: George Orwell
ISBN: ISBN-123456
Price: $10.5
Pages: 0
Publisher: Unknown Publisher
Year: Unknown
5. FULL CONSTRUCTOR (all parameters):
🎯 Master constructor called - Book: Pride and Prejudice
=== BOOK DETAILS ===
Title: Pride and Prejudice
Author: Jane Austen
ISBN: ISBN-789012
Price: $15.75
Pages: 432
Publisher: Penguin Classics
Year: 1813
6. BENEFITS OF CONSTRUCTOR CHAINING:
✅ Code Reusability: Common initialization in one place
✅ Maintainability: Changes only in master constructor
✅ Consistency: All objects initialized consistently
✅ Reduced Duplication: No repeated initialization code
7. BOOK COLLECTION:
🎯 Master constructor called - Book: Unknown Title
🔗 Default constructor → chained to full constructor
🎯 Master constructor called - Book: The Catcher in the Rye
🔗 Basic constructor → chained to full constructor
🎯 Master constructor called - Book: The Hobbit
🔗 Price constructor → chained to full constructor
🎯 Master constructor called - Book: Brave New World
🔗 ISBN constructor → chained to full constructor
🎯 Master constructor called - Book: Moby Dick
=== LIBRARY CATALOG ===
1. 📚 Unknown Title by Unknown Author - $0.0
2. 📚 The Catcher in the Rye by J.D. Salinger - $0.0
3. 📚 The Hobbit by J.R.R. Tolkien - $14.99
4. 📚 Brave New World by Aldous Huxley - $11.25
5. 📚 Moby Dick by Herman Melville - $18.5
8. CONSTRUCTOR CHAINING VISUALIZATION:
Book() → Book(String, String, String, double, int, String, int)
Book(String, String) → Book(String, String, String, double, int, String, int)
Book(String, String, double) → Book(String, String, String, double, int, String, int)
Book(String, String, String, double) → Book(String, String, String, double, int, String, int)

Example 3: Real-World Bank Account System

class BankAccount {
// 🎯 ATTRIBUTES
private String accountNumber;
private String accountHolder;
private double balance;
private String accountType;
private double interestRate;
private boolean isActive;
private String email;
private String phoneNumber;
private static int accountCounter = 1000;
// 🎯 CONSTRUCTOR 1: Default constructor - basic account
public BankAccount() {
this("Unknown", "Savings", 0.0);
System.out.println("🏦 Default account created with minimal information");
}
// 🎯 CONSTRUCTOR 2: Basic account with holder name
public BankAccount(String accountHolder) {
this(accountHolder, "Savings", 0.0);
System.out.println("🏦 Basic account created for: " + accountHolder);
}
// 🎯 CONSTRUCTOR 3: Account with holder and type
public BankAccount(String accountHolder, String accountType) {
this(accountHolder, accountType, 0.0);
System.out.println("🏦 " + accountType + " account created for: " + accountHolder);
}
// 🎯 CONSTRUCTOR 4: Account with holder, type, and initial deposit
public BankAccount(String accountHolder, String accountType, double initialDeposit) {
this.accountNumber = "ACC" + (accountCounter++);
this.accountHolder = accountHolder;
this.accountType = accountType;
this.balance = initialDeposit;
this.isActive = true;
// Set interest rate based on account type
switch(accountType.toLowerCase()) {
case "savings":
this.interestRate = 2.5;
break;
case "checking":
this.interestRate = 0.5;
break;
case "business":
this.interestRate = 1.5;
break;
default:
this.interestRate = 1.0;
}
// Generate email
this.email = accountHolder.toLowerCase().replace(" ", ".") + "@bank.com";
System.out.println("🏦 Full account created: " + accountNumber + " for " + accountHolder);
}
// 🎯 CONSTRUCTOR 5: Premium account with all details
public BankAccount(String accountHolder, String accountType, double initialDeposit, 
String email, String phoneNumber) {
this(accountHolder, accountType, initialDeposit); // Chain to constructor 4
this.email = email;
this.phoneNumber = phoneNumber;
System.out.println("🏦 Premium account created with contact details");
}
// 🎯 CONSTRUCTOR 6: Copy constructor
public BankAccount(BankAccount other) {
this.accountNumber = "ACC" + (accountCounter++);
this.accountHolder = other.accountHolder;
this.accountType = other.accountType;
this.balance = other.balance;
this.interestRate = other.interestRate;
this.isActive = other.isActive;
this.email = other.email;
this.phoneNumber = other.phoneNumber;
System.out.println("🏦 Account copied: " + accountNumber + " from " + other.accountNumber);
}
// 🎯 BUSINESS METHODS
public void deposit(double amount) {
if (isActive && amount > 0) {
balance += amount;
System.out.println("💰 Deposited $" + amount + " to " + accountNumber);
} else {
System.out.println("❌ Deposit failed");
}
}
public boolean withdraw(double amount) {
if (isActive && amount > 0 && amount <= balance) {
balance -= amount;
System.out.println("💸 Withdrawn $" + amount + " from " + accountNumber);
return true;
}
System.out.println("❌ Withdrawal failed");
return false;
}
public void applyInterest() {
if (isActive && balance > 0) {
double interest = balance * interestRate / 100;
balance += interest;
System.out.println("📈 Interest applied: $" + interest + " to " + accountNumber);
}
}
// 🎯 DISPLAY METHODS
public void displayAccountSummary() {
System.out.println("\n=== ACCOUNT SUMMARY ===");
System.out.println("Account: " + accountNumber);
System.out.println("Holder: " + accountHolder);
System.out.println("Type: " + accountType);
System.out.println("Balance: $" + balance);
System.out.println("Interest Rate: " + interestRate + "%");
System.out.println("Status: " + (isActive ? "Active" : "Inactive"));
}
public void displayFullDetails() {
System.out.println("\n=== ACCOUNT DETAILS ===");
System.out.println("Account Number: " + accountNumber);
System.out.println("Account Holder: " + accountHolder);
System.out.println("Account Type: " + accountType);
System.out.println("Balance: $" + balance);
System.out.println("Interest Rate: " + interestRate + "%");
System.out.println("Email: " + email);
System.out.println("Phone: " + (phoneNumber != null ? phoneNumber : "Not provided"));
System.out.println("Status: " + (isActive ? "Active" : "Inactive"));
}
// 🎯 GETTER METHODS
public String getAccountNumber() { return accountNumber; }
public String getAccountHolder() { return accountHolder; }
public double getBalance() { return balance; }
public String getAccountType() { return accountType; }
public double getInterestRate() { return interestRate; }
public boolean isActive() { return isActive; }
}
public class BankAccountSystem {
public static void main(String[] args) {
System.out.println("=== REAL-WORLD BANK ACCOUNT SYSTEM ===");
// 🎯 CREATING ACCOUNTS USING DIFFERENT CONSTRUCTORS
System.out.println("\n1. DEFAULT ACCOUNT:");
BankAccount account1 = new BankAccount();
account1.displayAccountSummary();
System.out.println("\n2. BASIC ACCOUNT (name only):");
BankAccount account2 = new BankAccount("Alice Johnson");
account2.displayAccountSummary();
System.out.println("\n3. SPECIFIC ACCOUNT TYPE:");
BankAccount account3 = new BankAccount("Bob Smith", "Checking");
account3.displayAccountSummary();
System.out.println("\n4. ACCOUNT WITH INITIAL DEPOSIT:");
BankAccount account4 = new BankAccount("Carol Davis", "Savings", 5000.0);
account4.displayAccountSummary();
System.out.println("\n5. PREMIUM ACCOUNT (all details):");
BankAccount account5 = new BankAccount("David Wilson", "Business", 10000.0, 
"[email protected]", "+1-555-0123");
account5.displayFullDetails();
System.out.println("\n6. COPY ACCOUNT:");
BankAccount account6 = new BankAccount(account5);
account6.displayFullDetails();
// 🎯 ACCOUNT OPERATIONS
System.out.println("\n7. ACCOUNT OPERATIONS:");
account4.deposit(1000.0);
account4.withdraw(500.0);
account4.applyInterest();
account4.displayAccountSummary();
// 🎯 BANK PORTFOLIO
System.out.println("\n8. BANK PORTFOLIO:");
BankAccount[] portfolio = {
new BankAccount(),
new BankAccount("Emma Brown"),
new BankAccount("Frank Miller", "Checking"),
new BankAccount("Grace Lee", "Savings", 3000.0),
new BankAccount("Henry Taylor", "Business", 15000.0, 
"[email protected]", "+1-555-0456")
};
displayPortfolio(portfolio);
// 🎯 CONSTRUCTOR OVERLOADING BENEFITS
System.out.println("\n9. BENEFITS OF CONSTRUCTOR OVERLOADING IN BANKING:");
System.out.println("✅ Customer Flexibility: Different account opening options");
System.out.println("✅ Operational Efficiency: Quick account creation for walk-ins");
System.out.println("✅ Data Integrity: Sensible defaults for missing information");
System.out.println("✅ Business Rules: Automatic interest rate assignment");
System.out.println("✅ Customer Experience: Progressive information collection");
}
public static void displayPortfolio(BankAccount[] accounts) {
System.out.println("\n=== BANK PORTFOLIO OVERVIEW ===");
double totalBalance = 0;
for (BankAccount account : accounts) {
account.displayAccountSummary();
totalBalance += account.getBalance();
}
System.out.println("\n📊 PORTFOLIO SUMMARY:");
System.out.println("Total Accounts: " + accounts.length);
System.out.println("Total Balance: $" + totalBalance);
}
}

Output:

=== REAL-WORLD BANK ACCOUNT SYSTEM ===
1. DEFAULT ACCOUNT:
🏦 Full account created: ACC1000 for Unknown
🏦 Default account created with minimal information
=== ACCOUNT SUMMARY ===
Account: ACC1000
Holder: Unknown
Type: Savings
Balance: $0.0
Interest Rate: 2.5%
Status: Active
2. BASIC ACCOUNT (name only):
🏦 Full account created: ACC1001 for Alice Johnson
🏦 Basic account created for: Alice Johnson
=== ACCOUNT SUMMARY ===
Account: ACC1001
Holder: Alice Johnson
Type: Savings
Balance: $0.0
Interest Rate: 2.5%
Status: Active
3. SPECIFIC ACCOUNT TYPE:
🏦 Full account created: ACC1002 for Bob Smith
🏦 Checking account created for: Bob Smith
=== ACCOUNT SUMMARY ===
Account: ACC1002
Holder: Bob Smith
Type: Checking
Balance: $0.0
Interest Rate: 0.5%
Status: Active
4. ACCOUNT WITH INITIAL DEPOSIT:
🏦 Full account created: ACC1003 for Carol Davis
=== ACCOUNT SUMMARY ===
Account: ACC1003
Holder: Carol Davis
Type: Savings
Balance: $5000.0
Interest Rate: 2.5%
Status: Active
5. PREMIUM ACCOUNT (all details):
🏦 Full account created: ACC1004 for David Wilson
🏦 Premium account created with contact details
=== ACCOUNT DETAILS ===
Account Number: ACC1004
Account Holder: David Wilson
Account Type: Business
Balance: $10000.0
Interest Rate: 1.5%
Email: [email protected]
Phone: +1-555-0123
Status: Active
6. COPY ACCOUNT:
🏦 Account copied: ACC1005 from ACC1004
=== ACCOUNT DETAILS ===
Account Number: ACC1005
Account Holder: David Wilson
Account Type: Business
Balance: $10000.0
Interest Rate: 1.5%
Email: [email protected]
Phone: +1-555-0123
Status: Active
7. ACCOUNT OPERATIONS:
💰 Deposited $1000.0 to ACC1003
💸 Withdrawn $500.0 from ACC1003
📈 Interest applied: $137.5 to ACC1003
=== ACCOUNT SUMMARY ===
Account: ACC1003
Holder: Carol Davis
Type: Savings
Balance: $5637.5
Interest Rate: 2.5%
Status: Active
8. BANK PORTFOLIO:
🏦 Full account created: ACC1006 for Unknown
🏦 Default account created with minimal information
🏦 Full account created: ACC1007 for Emma Brown
🏦 Basic account created for: Emma Brown
🏦 Full account created: ACC1008 for Frank Miller
🏦 Checking account created for: Frank Miller
🏦 Full account created: ACC1009 for Grace Lee
🏦 Full account created: ACC1010 for Henry Taylor
🏦 Premium account created with contact details
=== BANK PORTFOLIO OVERVIEW ===
=== ACCOUNT SUMMARY ===
Account: ACC1006
Holder: Unknown
Type: Savings
Balance: $0.0
Interest Rate: 2.5%
Status: Active
=== ACCOUNT SUMMARY ===
Account: ACC1007
Holder: Emma Brown
Type: Savings
Balance: $0.0
Interest Rate: 2.5%
Status: Active
=== ACCOUNT SUMMARY ===
Account: ACC1008
Holder: Frank Miller
Type: Checking
Balance: $0.0
Interest Rate: 0.5%
Status: Active
=== ACCOUNT SUMMARY ===
Account: ACC1009
Holder: Grace Lee
Type: Savings
Balance: $3000.0
Interest Rate: 2.5%
Status: Active
=== ACCOUNT SUMMARY ===
Account: ACC1010
Holder: Henry Taylor
Type: Business
Balance: $15000.0
Interest Rate: 1.5%
Status: Active
📊 PORTFOLIO SUMMARY:
Total Accounts: 5
Total Balance: $18000.0
9. BENEFITS OF CONSTRUCTOR OVERLOADING IN BANKING:
✅ Customer Flexibility: Different account opening options
✅ Operational Efficiency: Quick account creation for walk-ins
✅ Data Integrity: Sensible defaults for missing information
✅ Business Rules: Automatic interest rate assignment
✅ Customer Experience: Progressive information collection

Example 4: Advanced Constructor Overloading Patterns

class Product {
private String productId;
private String name;
private String description;
private double price;
private int stockQuantity;
private String category;
private String manufacturer;
private double weight;
private String dimensions;
private boolean isAvailable;
// 🎯 PRIVATE MASTER CONSTRUCTOR
private Product(String productId, String name, String description, double price, 
int stockQuantity, String category, String manufacturer, 
double weight, String dimensions, boolean isAvailable) {
this.productId = productId;
this.name = name;
this.description = description;
this.price = price;
this.stockQuantity = stockQuantity;
this.category = category;
this.manufacturer = manufacturer;
this.weight = weight;
this.dimensions = dimensions;
this.isAvailable = isAvailable;
}
// 🎯 STATIC FACTORY METHODS (Alternative to constructor overloading)
// Factory 1: Basic product with just name and price
public static Product createBasicProduct(String name, double price) {
String id = "PROD-" + System.currentTimeMillis();
return new Product(id, name, "No description available", price, 
0, "General", "Unknown", 0.0, "N/A", true);
}
// Factory 2: Product with category
public static Product createCategorizedProduct(String name, double price, String category) {
String id = "PROD-" + System.currentTimeMillis();
return new Product(id, name, "No description available", price, 
0, category, "Unknown", 0.0, "N/A", true);
}
// Factory 3: Full product details
public static Product createFullProduct(String name, String description, double price, 
int stockQuantity, String category, String manufacturer) {
String id = "PROD-" + System.currentTimeMillis();
return new Product(id, name, description, price, stockQuantity, 
category, manufacturer, 0.0, "N/A", true);
}
// Factory 4: Physical product with weight and dimensions
public static Product createPhysicalProduct(String name, String description, double price, 
int stockQuantity, String category, String manufacturer,
double weight, String dimensions) {
String id = "PROD-" + System.currentTimeMillis();
return new Product(id, name, description, price, stockQuantity, 
category, manufacturer, weight, dimensions, true);
}
// Factory 5: Copy product
public static Product copyProduct(Product original) {
return new Product(
"PROD-" + System.currentTimeMillis(),
original.name,
original.description,
original.price,
original.stockQuantity,
original.category,
original.manufacturer,
original.weight,
original.dimensions,
original.isAvailable
);
}
// 🎯 BUILDER PATTERN (Another alternative)
public static class Builder {
private String name;
private double price;
private String description = "No description";
private int stockQuantity = 0;
private String category = "General";
private String manufacturer = "Unknown";
private double weight = 0.0;
private String dimensions = "N/A";
public Builder(String name, double price) {
this.name = name;
this.price = price;
}
public Builder description(String description) {
this.description = description;
return this;
}
public Builder stockQuantity(int quantity) {
this.stockQuantity = quantity;
return this;
}
public Builder category(String category) {
this.category = category;
return this;
}
public Builder manufacturer(String manufacturer) {
this.manufacturer = manufacturer;
return this;
}
public Builder weight(double weight) {
this.weight = weight;
return this;
}
public Builder dimensions(String dimensions) {
this.dimensions = dimensions;
return this;
}
public Product build() {
String id = "PROD-" + System.currentTimeMillis();
return new Product(id, name, description, price, stockQuantity, 
category, manufacturer, weight, dimensions, true);
}
}
// 🎯 DISPLAY METHODS
public void displayBasicInfo() {
System.out.println("🛒 " + name + " - $" + price + " (" + category + ")");
}
public void displayFullInfo() {
System.out.println("\n=== PRODUCT DETAILS ===");
System.out.println("ID: " + productId);
System.out.println("Name: " + name);
System.out.println("Description: " + description);
System.out.println("Price: $" + price);
System.out.println("Stock: " + stockQuantity);
System.out.println("Category: " + category);
System.out.println("Manufacturer: " + manufacturer);
System.out.println("Weight: " + weight + " kg");
System.out.println("Dimensions: " + dimensions);
System.out.println("Available: " + (isAvailable ? "Yes" : "No"));
}
// 🎯 GETTER METHODS
public String getProductId() { return productId; }
public String getName() { return name; }
public double getPrice() { return price; }
public int getStockQuantity() { return stockQuantity; }
}
public class AdvancedPatterns {
public static void main(String[] args) {
System.out.println("=== ADVANCED CONSTRUCTOR OVERLOADING PATTERNS ===");
// 🎯 USING STATIC FACTORY METHODS
System.out.println("\n1. STATIC FACTORY METHODS:");
Product product1 = Product.createBasicProduct("Laptop", 999.99);
product1.displayBasicInfo();
Product product2 = Product.createCategorizedProduct("Smartphone", 699.99, "Electronics");
product2.displayBasicInfo();
Product product3 = Product.createFullProduct("Coffee Mug", "Ceramic coffee mug with handle", 
15.99, 100, "Kitware", "HomeGoods Inc.");
product3.displayFullInfo();
Product product4 = Product.createPhysicalProduct("Gaming Chair", "Ergonomic gaming chair", 
299.99, 50, "Furniture", "ComfortSeats", 
15.5, "50x60x120 cm");
product4.displayFullInfo();
// 🎯 USING BUILDER PATTERN
System.out.println("\n2. BUILDER PATTERN:");
Product product5 = new Product.Builder("Wireless Headphones", 199.99)
.description("Noise-cancelling wireless headphones")
.category("Electronics")
.manufacturer("SoundTech")
.stockQuantity(25)
.weight(0.3)
.dimensions("18x15x8 cm")
.build();
product5.displayFullInfo();
Product product6 = new Product.Builder("Desk Lamp", 49.99)
.description("LED desk lamp with adjustable brightness")
.category("Home Office")
.stockQuantity(75)
.build();
product6.displayFullInfo();
// 🎯 COMPARISON OF APPROACHES
System.out.println("\n3. COMPARISON OF OBJECT CREATION PATTERNS:");
System.out.println("🔹 Constructor Overloading:");
System.out.println("   Pros: Simple, familiar, compile-time safety");
System.out.println("   Cons: Can become unwieldy with many parameters");
System.out.println("🔹 Static Factory Methods:");
System.out.println("   Pros: Descriptive names, can cache objects, can return subtypes");
System.out.println("   Cons: Not as discoverable as constructors");
System.out.println("🔹 Builder Pattern:");
System.out.println("   Pros: Very readable, handles many parameters well");
System.out.println("   Cons: More verbose, requires builder class");
// 🎯 REAL-WORLD SCENARIOS
System.out.println("\n4. REAL-WORLD USAGE SCENARIOS:");
System.out.println("🛒 E-commerce: Different product creation flows");
System.out.println("   - Quick add: Basic product (name, price)");
System.out.println("   - Category setup: Categorized product");
System.out.println("   - Full setup: Complete product details");
System.out.println("   - Physical goods: Products with dimensions/weight");
System.out.println("🏦 Banking: Different account types");
System.out.println("   - Walk-in: Basic account");
System.out.println("   - Online: Full account with verification");
System.out.println("   - Business: Premium account with extra features");
// 🎯 PERFORMING OPERATIONS
System.out.println("\n5. PRODUCT OPERATIONS:");
displayProductCatalog(new Product[]{product1, product2, product3, product4, product5, product6});
}
public static void displayProductCatalog(Product[] products) {
System.out.println("\n=== PRODUCT CATALOG ===");
double totalValue = 0;
for (Product product : products) {
product.displayBasicInfo();
totalValue += product.getPrice() * product.getStockQuantity();
}
System.out.println("\n📊 CATALOG SUMMARY:");
System.out.println("Total Products: " + products.length);
System.out.println("Total Inventory Value: $" + totalValue);
}
}

Output:

=== ADVANCED CONSTRUCTOR OVERLOADING PATTERNS ===
1. STATIC FACTORY METHODS:
🛒 Laptop - $999.99 (General)
🛒 Smartphone - $699.99 (Electronics)
=== PRODUCT DETAILS ===
ID: PROD-1701234567892
Name: Coffee Mug
Description: Ceramic coffee mug with handle
Price: $15.99
Stock: 100
Category: Kitchenware
Manufacturer: HomeGoods Inc.
Weight: 0.0 kg
Dimensions: N/A
Available: Yes
=== PRODUCT DETAILS ===
ID: PROD-1701234567893
Name: Gaming Chair
Description: Ergonomic gaming chair
Price: $299.99
Stock: 50
Category: Furniture
Manufacturer: ComfortSeats
Weight: 15.5 kg
Dimensions: 50x60x120 cm
Available: Yes
2. BUILDER PATTERN:
=== PRODUCT DETAILS ===
ID: PROD-1701234567894
Name: Wireless Headphones
Description: Noise-cancelling wireless headphones
Price: $199.99
Stock: 25
Category: Electronics
Manufacturer: SoundTech
Weight: 0.3 kg
Dimensions: 18x15x8 cm
Available: Yes
=== PRODUCT DETAILS ===
ID: PROD-1701234567895
Name: Desk Lamp
Description: LED desk lamp with adjustable brightness
Price: $49.99
Stock: 75
Category: Home Office
Manufacturer: Unknown
Weight: 0.0 kg
Dimensions: N/A
Available: Yes
3. COMPARISON OF OBJECT CREATION PATTERNS:
🔹 Constructor Overloading:
Pros: Simple, familiar, compile-time safety
Cons: Can become unwieldy with many parameters
🔹 Static Factory Methods:
Pros: Descriptive names, can cache objects, can return subtypes
Cons: Not as discoverable as constructors
🔹 Builder Pattern:
Pros: Very readable, handles many parameters well
Cons: More verbose, requires builder class
4. REAL-WORLD USAGE SCENARIOS:
🛒 E-commerce: Different product creation flows
- Quick add: Basic product (name, price)
- Category setup: Categorized product
- Full setup: Complete product details
- Physical goods: Products with dimensions/weight
🏦 Banking: Different account types
- Walk-in: Basic account
- Online: Full account with verification
- Business: Premium account with extra features
5. PRODUCT OPERATIONS:
=== PRODUCT CATALOG ===
🛒 Laptop - $999.99 (General)
🛒 Smartphone - $699.99 (Electronics)
🛒 Coffee Mug - $15.99 (Kitchenware)
🛒 Gaming Chair - $299.99 (Furniture)
🛒 Wireless Headphones - $199.99 (Electronics)
🛒 Desk Lamp - $49.99 (Home Office)
📊 CATALOG SUMMARY:
Total Products: 6
Total Inventory Value: $18048.5

Constructor Overloading Rules

Valid Overloading:

// Different number of parameters
public Student(String name) { }
public Student(String name, int age) { }
// Different types of parameters  
public Student(String name, int age) { }
public Student(String name, double gpa) { }
// Different order of parameters
public Student(String name, int age) { }
public Student(int age, String name) { }

Invalid Overloading:

// ❌ Same parameter types - compiler error
public Student(String name) { }
public Student(String firstName) { } // Not allowed
// ❌ Just different return type - not valid for constructors

Best Practices

1. Start with default constructor for maximum flexibility
2. Use constructor chaining with this() to avoid code duplication
3. Provide sensible defaults for missing parameters
4. Order constructors from simplest to most complex
5. Consider static factory methods when constructors become too numerous
6. Use builder pattern for classes with many optional parameters
7. Always include a copy constructor when deep copying is needed

Common Patterns

Telescoping Constructor Pattern:

public class Product {
public Product(String name) { }
public Product(String name, double price) { }
public Product(String name, double price, String category) { }
// ... more constructors
}

JavaBean Pattern:

public class Product {
public Product() { } // Default constructor
// Use setters for configuration
}

Builder Pattern:

Product product = new Product.Builder()
.name("Laptop")
.price(999.99)
.category("Electronics")
.build();

Conclusion

Constructor overloading is a powerful technique for flexible object creation:

• ✅ Multiple initialization options for different use cases
• ✅ Constructor chaining reduces code duplication
• ✅ Sensible defaults improve API usability
• ✅ Flexible object creation patterns for various scenarios

Key Takeaways:

1. Overload constructors by varying parameter lists
2. Use this() for constructor chaining and code reuse
3. Provide multiple construction paths for different scenarios
4. Consider alternative patterns when constructors become complex
5. Always think about API usability from the user's perspective

Remember: Good constructor design is like good customer service - it should make object creation easy and intuitive no matter what information the user has available! 🎯🏗️

Now you're equipped to design flexible, user-friendly classes with comprehensive constructor overloading!