Java Constructor

Exercises Interview question Video Tutorial Discussion

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

Feature	Constructor	Method
Name	Same as class name	Any valid identifier
Return Type	No return type ( not even void )	Must have a return type
Call	Called automatically on object creation	Must be called explicitly
Overloading	Yes	Yes
Overriding	No	Yes

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.