Types of Constructors in Java

In Java, constructors are special methods used to initialize objects. There are several types of constructors:

1. Default Constructor

  • Created automatically by Java if no constructor is defined
  • Has no parameters
  • Initializes instance variables with default values (0, null, false) 
public class MyClass {
    // Default constructor (implicit if none defined)
    public MyClass() {
        // Initialization code
    }
}

2. Parameterized Constructor

  • Accepts parameters to initialize objects with specific values
  • Allows different initialization for different objects 
public class Student {
    String name;
    int age;

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

3. Copy Constructor

  • Creates an object by copying values from another object
  • Useful for creating a copy of an existing object 
public class Student {
    String name;
    int age;

    // Copy constructor
    public Student(Student other) {
        this.name = other.name;
        this.age = other.age;
    }
}

4. Constructor Overloading

  • Having multiple constructors with different parameters
  • Provides different ways to initialize objects 
public class Rectangle {
    int length, width;

    // Constructor 1
    public Rectangle() {
        length = width = 0;
    }

    // Constructor 2
    public Rectangle(int side) {
        length = width = side;
    }

    // Constructor 3
    public Rectangle(int l, int w) {
        length = l;
        width = w;
    }
}

5. Private Constructor

  • Can only be accessed within the class
  • Used in singleton design pattern
  • Prevents instantiation from outside the class 
public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // private constructor
    }

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

6. Constructor Chaining

  • Calling one constructor from another constructor
  • Achieved using this() keyword
  • Must be the first statement in the constructor 
public class Employee {
    String name;
    int id;
    String department;

    public Employee() {
        this("Unknown", 0); // calls 2-arg constructor
    }

    public Employee(String name, int id) {
        this(name, id, "General"); // calls 3-arg constructor
    }

    public Employee(String name, int id, String department) {
        this.name = name;
        this.id = id;
        this.department = department;
    }
}

Each type of constructor serves different purposes in object initialization and provides flexibility in how objects are created in Java programs. (TBD)