Constructors

The Vital Role of Constructors in Object Lifecycle:

In Java, when the new operator allocates contiguous Heap memory for an object, the object's instance fields initially hold default language values (e.g., 0, 0.0, null, false). A Constructor is a specialized member block designed specifically to initialize those data members to meaningful, valid business states before the object reference is returned to the program.

The Three Non-Negotiable Syntactic Invariants:

1. Exact Name Parity: The constructor MUST have the exact same identifier as the enclosing class, matching capitalization identically (e.g., in class Account, the constructor must be Account()).
2. Zero Return Type: A constructor has NO return type—not even void.
   Warning: If you write public void Account() { ... }, the Java compiler will NOT report an error; instead, it will compile it as a regular member method named Account and will NOT invoke it upon new Account()!
3. Automatic Invocation: A constructor cannot be called explicitly like an ordinary method (e.g., obj.Account(); is invalid syntax). It is invoked automatically during the execution of the new operator.

Taxonomy of Constructors in Java:

Resolving Variable Shadowing:

When formal parameter names in a constructor are identical to instance variable names, the local parameters 'shadow' (hide) the instance variables. The this keyword is an implicit reference variable pointing to the currently executing object instance on the Heap.

public class Employee {
    private int empId;
    private String name;

    // Parameter names match instance variable names exactly:
    public Employee(int empId, String name) {
        this.empId = empId; // 'this.empId' refers to instance field; 'empId' refers to parameter
        this.name = name;
    }
}

Constructor Chaining via this():

Constructor chaining is the technique of invoking one constructor from another constructor within the same class using this(...). This prevents code duplication when multiple overloaded constructors perform overlapping initialization.

Constructor Overloading:

Like methods, constructors can be overloaded by providing multiple constructor definitions with different parameter counts or parameter types within the same class. This empowers client code to construct objects flexibly depending on available input data.

The Copy Constructor Paradigm:

A Copy Constructor is a parameterized constructor that accepts an existing object of the SAME class as its parameter and initializes the new object with duplicates of the fields of the passed object:

public class Rectangle {
    private int length, breadth;

    // Normal parameterized constructor
    public Rectangle(int l, int b) {
        length = l; breadth = b;
    }

    // Copy Constructor
    public Rectangle(Rectangle existing) {
        this.length = existing.length;
        this.breadth = existing.breadth;
    }
}
// Usage: Rectangle r1 = new Rectangle(10, 20);
//        Rectangle r2 = new Rectangle(r1); // r2 is an independent clone!

Constructor vs Member Method:

Automatic Cleanup vs finalize():

In languages like C++, every constructor has a corresponding Destructor (e.g., ~ClassName()) to manually release allocated Heap memory. In Java, destructors do NOT exist because memory management is completely automated by the JVM Garbage Collector.

An object becomes eligible for garbage collection when it is no longer reachable from any live Stack reference. Java historically provided a protected void finalize() method invoked before an object is swept from memory, though modern Java encourages explicit resource release via try-with-resources.

Model Program 1: ICSE Classic 'BookFair' Class

import java.util.Scanner;

public class BookFair {
    // Instance Variables
    private String bname;
    private double price;

    // 1. Default / Non-Parameterized Constructor
    public BookFair() {
        bname = "";
        price = 0.0;
    }

    // 2. Member Method to input data
    public void input() {
        Scanner in = new Scanner(System.in);
        System.out.print("Enter Book Name: ");
        bname = in.nextLine();
        System.out.print("Enter Book Price: Rs. ");
        price = in.nextDouble();
    }

    // 3. Member Method to calculate discounted price
    public void calculate() {
        double discountPercent;
        if (price <= 1000.0) {
            discountPercent = 2.0;
        } else if (price <= 3000.0) {
            discountPercent = 10.0;
        } else {
            discountPercent = 15.0;
        }

        double discountAmount = (price * discountPercent) / 100.0;
        price = price - discountAmount;
    }

    // 4. Member Method to display details
    public void display() {
        System.out.println("--------------------------------");
        System.out.println("BOOK FAIR INVOICE");
        System.out.println("Book Name          : " + bname);
        System.out.println("Price After Discount: Rs. " + price);
        System.out.println("--------------------------------");
    }

    public static void main(String[] args) {
        BookFair book = new BookFair(); // Constructor executes here!
        book.input();
        book.calculate();
        book.display();
    }
}

Model Program 2: ICSE 'RailwayTicket' Reservation System

import java.util.Scanner;

public class RailwayTicket {
    private String name;
    private String coach;
    private long mobno;
    private int amt;
    private double totalamt;

    // Parameterized Constructor
    public RailwayTicket(String name, String coach, long mobno, int amt) {
        this.name = name;
        this.coach = coach;
        this.mobno = mobno;
        this.amt = amt;
        this.totalamt = 0.0;
    }

    public void compute() {
        int surcharge = 0;
        if (coach.equalsIgnoreCase("First_AC")) {
            surcharge = 700;
        } else if (coach.equalsIgnoreCase("Second_AC")) {
            surcharge = 500;
        } else if (coach.equalsIgnoreCase("Third_AC")) {
            surcharge = 250;
        } else if (coach.equalsIgnoreCase("Sleeper")) {
            surcharge = 0;
        }
        totalamt = amt + surcharge;
    }

    public void display() {
        System.out.println("=================================");
        System.out.println("INDIAN RAILWAYS RESERVATION SLIP");
        System.out.println("Passenger Name : " + name);
        System.out.println("Coach Selected : " + coach);
        System.out.println("Mobile Number  : " + mobno);
        System.out.println("Base Amount    : Rs. " + amt);
        System.out.println("Total Payable  : Rs. " + totalamt);
        System.out.println("=================================");
    }

    public static void main(String[] args) {
        RailwayTicket ticket = new RailwayTicket("Vikram Singhania", "First_AC", 9876543210L, 1850);
        ticket.compute();
        ticket.display();
    }
}