Java.Core.Define the concept of a “constructor.”

1. Key Characteristics of a Constructor

✅ Same name as the class
✅ No return type (not even void)
✅ Called automatically when an object is instantiated
✅ Used to initialize instance variables
✅ Can be overloaded (multiple constructors in the same class)

2. Example: Basic Constructor

class Car {
    String model;

    // Constructor (same name as class)
    Car(String modelName) {
        model = modelName; // Initializing instance variable
    }

    void display() {
        System.out.println("Car Model: " + model);
    }
}

public class ConstructorExample {
    public static void main(String[] args) {
        Car car1 = new Car("Tesla Model 3"); // Constructor is called
        car1.display(); // Output: Car Model: Tesla Model 3
    }
}

✅ The constructor initializes model when Car is created.

3. Types of Constructors

(a) Default Constructor

A constructor without parameters.
If no constructor is explicitly defined, Java automatically provides a default constructor.

Example: Default Constructor

class Animal {
    Animal() { // No parameters
        System.out.println("An Animal is Created!");
    }
}

public class DefaultConstructorExample {
    public static void main(String[] args) {
        Animal a = new Animal(); // Calls the default constructor
    }
}

✅ Output:

An Animal is Created!

(b) Parameterized Constructor

Accepts arguments to initialize fields.

Example: Parameterized Constructor

class Person {
    String name;
    int age;

    // Parameterized constructor
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

public class ParameterizedConstructorExample {
    public static void main(String[] args) {
        Person p = new Person("Alice", 25);
        p.display(); // Output: Alice is 25 years old.
    }
}

✅ Uses constructor parameters to initialize name and age.

(c) Copy Constructor

Creates a new object by copying the values of an existing object.

Example: Copy Constructor

class Book {
    String title;

    // Constructor
    Book(String title) {
        this.title = title;
    }

    // Copy Constructor
    Book(Book other) {
        this.title = other.title;
    }

    void display() {
        System.out.println("Book Title: " + title);
    }
}

public class CopyConstructorExample {
    public static void main(String[] args) {
        Book b1 = new Book("Java Programming");
        Book b2 = new Book(b1); // Copy constructor

        b1.display(); // Java Programming
        b2.display(); // Java Programming
    }
}

✅ Creates an exact copy of b1 in b2.

(d) Private Constructor

Used to restrict object creation (commonly used in the Singleton pattern).

Example: Singleton Pattern Using a Private Constructor

class Singleton {
    private static Singleton instance;

    private Singleton() { // Private constructor
        System.out.println("Singleton Instance Created");
    }

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

public class PrivateConstructorExample {
    public static void main(String[] args) {
        Singleton obj1 = Singleton.getInstance(); // Only one instance
        Singleton obj2 = Singleton.getInstance(); // Same instance reused
    }
}

✅ Output:

Singleton Instance Created

🛑 Prevents multiple object creation!

4. Constructor Overloading

Multiple constructors in the same class, but with different parameters.

Example: Constructor Overloading

class Employee {
    String name;
    int age;

    // Constructor 1
    Employee() {
        this.name = "Unknown";
        this.age = 0;
    }

    // Constructor 2
    Employee(String name) {
        this.name = name;
        this.age = 0;
    }

    // Constructor 3
    Employee(String name, int age) {
        this.name = name;
        this.age = age;
    }

    void display() {
        System.out.println("Employee: " + name + ", Age: " + age);
    }
}

public class ConstructorOverloadingExample {
    public static void main(String[] args) {
        Employee e1 = new Employee();
        Employee e2 = new Employee("Bob");
        Employee e3 = new Employee("Alice", 30);

        e1.display(); // Employee: Unknown, Age: 0
        e2.display(); // Employee: Bob, Age: 0
        e3.display(); // Employee: Alice, Age: 30
    }
}

✅ Different constructors allow flexible object creation.

5. Difference Between Constructor and Method

Feature	Constructor	Method
Purpose	Initializes an object	Defines behavior of an object
Name	Same as the class name	Can have any name
Return Type	❌ No return type	✅ Has a return type
Called When?	Automatically at object creation	Explicitly called
Overloading	✅ Yes, multiple constructors can exist	✅ Yes, multiple methods can exist

✅ Example: Constructor vs. Method

class Student {
    String name;

    // Constructor
    Student(String name) {
        this.name = name;
    }

    // Method
    void display() {
        System.out.println("Student Name: " + name);
    }
}

public class ConstructorVsMethodExample {
    public static void main(String[] args) {
        Student s = new Student("Alice"); // Constructor called
        s.display(); // Method called
    }
}

✅ Constructor initializes, method displays.

6. Summary

Constructor Type	Description
Default Constructor	No parameters, auto-created if not defined.
Parameterized Constructor	Accepts arguments to initialize fields.
Copy Constructor	Creates a new object by copying another object.
Private Constructor	Restricts object creation (Singleton pattern).
Constructor Overloading	Multiple constructors with different parameters.

7. Conclusion

✅ A constructor is a special method used to initialize objects in Java.
✅ It runs automatically when an object is created.
✅ It can be overloaded and customized for different initialization scenarios.