4.3. Constructors

A constructor is a special method that runs automatically when an object is created.

A constructor is unique in that it is automatically executed at the time of object creation. Unlike regular methods that require explicit calls, constructors are invoked with the 'new' keyword when an object is instantiated. This automatic invocation allows for setting up initial states and configurations for objects, which is essential for proper functionality.

Think of a constructor like a factory worker who immediately begins assembling a product (the object) right after receiving the raw materials. As soon as the worker is given the parts, they start working to ensure the product is ready for sale, just as a constructor sets the initial state of an object.

🔧 Features: ● Same name as the class ● No return type (not even void) ● Used to initialize objects

The features of constructors highlight their special role in object-oriented programming. Firstly, constructors share the same name as the class they belong to, which differentiates them from other methods. Secondly, they do not have a return type, including 'void', signifying that they are not intended to produce a return value but instead focus on initializing the object. Lastly, their primary purpose is to set up initial values for the object's attributes, ensuring that when an object is created, it is ready for use.

Imagine a chef in a restaurant. When a new dish (object) is ordered, the chef (constructor) begins to prepare it with specific ingredients (initial values), ensuring everything is perfectly set for serving. Just like the chef does not need to say 'I will serve the dish' (no return type), their focus is solely on creating a dish that is ready to enjoy.

✅ Types of Constructors: A. Default Constructor: class Bike { Bike() { System.out.println("Bike is created"); } } public class Main { public static void main(String[] args) { Bike b = new Bike(); // calls constructor } } B. Parameterized Constructor: class Car { String model; Car(String m) { model = m; } void show() { System.out.println("Model: " + model); } } C. Constructor Overloading: Multiple constructors with different arguments. class Rectangle { int length, width; Rectangle() { length = width = 0; } Rectangle(int l, int w) { length = l; width = w; } void area() { System.out.println("Area: " + (length * width)); } }

Constructors can be categorized into different types, enriching the way we can initialize objects. A default constructor is defined without parameters. It is useful for initializing objects with default values. For example, in the 'Bike' class, when a 'Bike' object is created, a message is printed. A parameterized constructor, like in the 'Car' class, allows us to pass parameters to set specific attributes at the time of object creation. Here, we assign the 'model' to a value provided during the object instantiation. Finally, constructor overloading is the capability to have multiple constructors with different parameter lists, as demonstrated in the 'Rectangle' class. Here, both a default and a parameterized constructor allow for more flexible object creation.

Consider booking a hotel room. The default constructor is akin to booking a room without specifying exact preferences—when you check in, you get whatever is available. The parameterized constructor is like specifying exactly what kind of room you want, such as a single room with a sea view. Constructor overloading resembles having different ways to book a room—online, via phone, or through an agent—where each method may require different information but serves the same purpose of securing a room.

--