Constructors in Java

What is a Constructor?

A Constructor is a special block of code similar to a method. It is invoked automatically when an object of a class is created. A constructor has the same name as the class and does not have a return type. Example:

class Student {
    String name;
    int age;

    // Constructor
    Student(String n, int a) {
        name = n;
        age = a;
    }

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

public class ConstructorExample {
    public static void main(String[] args) {
        Student s = new Student("Alice", 20);
        s.display();
    }
}
  

Output: Name: Alice, Age: 20

Objectives of Using Constructors

Constructors ensure that object attributes are initialized properly, improving code readability and maintainability. For example, a constructor can set default values automatically when an object is created.

Advantages

Constructors automatically initialize objects, reducing errors and allowing flexibility through constructor overloading. This ensures objects are ready for use immediately after creation.

Limitations

Constructors cannot return values and cannot be called like regular methods. Overusing constructors for complex logic can make the code hard to maintain.

Types of Constructors in Java

Default Constructor: Initializes objects with default values.
Example:

class Demo {
    int x;
    Demo() {
        x = 10;
    }
    void display() { System.out.println(x); }
}
  

Parameterized Constructor: Initializes objects with specified values.
Example:

class Demo {
    int x;
    Demo(int val) {
        x = val;
    }
    void display() { System.out.println(x); }
}
  

Copy Constructor: Creates a new object as a copy of an existing object.
Example:

class Demo {
    int x;
    Demo(int val) { x = val; }

    // Copy Constructor
    Demo(Demo d) { x = d.x; }

    void display() { System.out.println(x); }
}
  

Best Practices

Always initialize mandatory attributes in constructors, keep them simple, use overloading for flexibility, and avoid complex operations inside constructors.