DEV Community

Sudhakar V
Sudhakar V

Posted on

Types of Constructor

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
    }
}
Enter fullscreen mode Exit fullscreen mode

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;
    }
}
Enter fullscreen mode Exit fullscreen mode

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;
    }
}
Enter fullscreen mode Exit fullscreen mode

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;
    }
}
Enter fullscreen mode Exit fullscreen mode

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;
    }
}
Enter fullscreen mode Exit fullscreen mode

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;
    }
}
Enter fullscreen mode Exit fullscreen mode

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

Top comments (0)