Loading
A constructor in Java is a special method used to initialize objects. Unlike regular methods, a constructor is automatically called when a new instance of a class is created. Constructors help set up initial values for object attributes and ensure your objects start life in a valid state.


Types of Constructors in Java

1. Default Constructor

A default constructor is a constructor with no parameters. If you don’t define any constructor in your class, Java automatically provides a default constructor that initializes object fields to default values (like 0 for integers, null for objects).


Syntax:

ClassName() {
    // constructor body
}


Example:

class Message {
    Message() {
        System.out.println("QUIPO HOUSE");
    }

    public static void main(String[] args) {
        Message obj = new Message(); // Calls default constructor
    }
}


Output:

QUIPO HOUSE


2. Parameterized Constructor

A parameterized constructor accepts arguments, allowing you to assign specific values to object fields at the time of creation.


Syntax:

ClassName(type param1, type param2) {
    // constructor body
}


Example:

public class Identifier {
    String msg, msg1;

    Identifier(String msg, String msg1) {
        this.msg = msg;
        this.msg1 = msg1;
    }

    void message() {
        System.out.println(msg + " " + msg1);
    }

    public static void main(String[] args) {
        Identifier obj = new Identifier("Message", "msg");
        obj.message();
    }
}


Output:

Message msg


3. Copy Constructor

Java does not provide a built-in copy constructor, but you can create one to copy the values from one object to another.


Example:

class Employee {
    String name;
    int age;

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

    // Copy Constructor
    Employee(Employee e) {
        this.name = e.name;
        this.age = e.age;
    }

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

    public static void main(String[] args) {
        Employee e1 = new Employee("John", 25);
        Employee e2 = new Employee(e1); // Using copy constructor

        e1.display();
        e2.display();
    }
}


Output:

Name: John, Age: 25 Name: John, Age: 25


4. Constructor Chaining

Constructor chaining allows one constructor to call another constructor in the same class using this(). This is useful for code reusability and reducing duplication.


Example:

class Student {
    String name;
    int age;

    // Default Constructor calling Parameterized Constructor
    Student() {
        this("Unknown", 0);
    }

    Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 = new Student("Alice", 22);
        s1.display();
        s2.display();
    }
}


Output:

Name: Unknown, Age: 0 Name: Alice, Age: 22


Constructor vs Method: Key Differences

FeatureConstructorMethod
NameSame as class nameAny valid identifier
Return TypeNo return type ( not even void )Must have a return type
CallCalled automatically on object creationMust be called explicitly
OverloadingYesYes
OverridingNoYes


Key Points

  • A constructor must have the same name as the class.
  • Constructors do not have a return type.
  • Constructors cannot be final, static, abstract, or synchronized.
  • If no constructor is defined, Java provides a default one automatically.
  • You can overload constructors by defining multiple constructors with different parameter lists.


Tips: Use constructors to ensure your objects are always created with valid, meaningful data. Constructor chaining and copy constructors can help you write cleaner, more reusable code.