Constructors in Java

In Java, constructors are special methods used to initialize objects of a class. They are called automatically when an object is created and help set the initial state of the object.

---

What is a Constructor?

• A constructor has the same name as the class.
• It does not have a return type, not even void.
• Used to initialize object attributes when an object is created.

Syntax:

class ClassName {
    // Constructor
    ClassName() {
        // Initialization code
    }
}

Note: If you don’t define a constructor, Java provides a default constructor automatically.

---

Types of Constructors

A. Default Constructor

• Provided by Java if no constructor is explicitly defined.
• No parameters.
• Initializes objects with default values.

Example – Default Constructor Provided by Java:

class Car {
    String color;
    int speed;
}

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car(); // Default constructor
        System.out.println("Color: " + myCar.color); // null
        System.out.println("Speed: " + myCar.speed); // 0
    }
}

Note: Default values: null for objects, 0 for numeric types, false for boolean.

---

B. Parameterized Constructor

• Takes parameters to initialize object attributes.
• Allows you to create objects with custom values.

Example – Parameterized Constructor:

class Car {
    String color;
    int speed;

    // Parameterized Constructor
    Car(String c, int s) {
        color = c;
        speed = s;
    }

    void display() {
        System.out.println(color + " car is driving at " + speed + " km/h");
    }
}

public class Main {
    public static void main(String[] args) {
        Car car1 = new Car("Red", 80);
        Car car2 = new Car("Blue", 120);

        car1.display();
        car2.display();
    }
}

Output:

Red car is driving at 80 km/h
Blue car is driving at 120 km/h

Note: Parameterized constructors make object creation more flexible and readable.

---

Constructor Overloading

Java allows multiple constructors in the same class with different parameter lists. This is called constructor overloading.

Example:

class Car {
    String color;
    int speed;

    Car() { // Default
        color = "White";
        speed = 0;
    }

    Car(String c) { // Single parameter
        color = c;
        speed = 50;
    }

    Car(String c, int s) { // Two parameters
        color = c;
        speed = s;
    }

    void display() {
        System.out.println(color + " car at " + speed + " km/h");
    }
}

public class Main {
    public static void main(String[] args) {
        Car car1 = new Car();
        Car car2 = new Car("Red");
        Car car3 = new Car("Blue", 100);

        car1.display();
        car2.display();
        car3.display();
    }
}

Output:

White car at 0 km/h
Red car at 50 km/h
Blue car at 100 km/h

---

Points to Remember

• Constructor name = class name, no return type.
• Default constructor is provided automatically if no constructor is defined.
• Parameterized constructors allow custom initialization.
• Constructor overloading helps initialize objects in different ways.
• Called automatically when an object is created.