5.6. Constructor and Object Initialization

A constructor is a special method that is automatically called when an object is created. It is used to initialize the object.

• Constructor name must be the same as the class name.
• It has no return type (not even void).

A constructor is a specific kind of method in Java that is invoked when a new object is instantiated from a class. The constructor has the same name as the class and doesn't return any value, not even 'void'. This distinguishes it from regular methods. The main purpose of constructors is to prepare the new object for use by initializing its attributes with initial values.

Think of a constructor like a factory assembly line. When you want to create a car, you send a request to the factory. The factory builds the car for you based on the specifications you provided (like color and model). The moment the factory finishes the car, it hands it over to you. Similarly, when you create an object in Java, the constructor prepares the object (like setting its attributes) and delivers it to you.

Example:

class Car {
    String model;
    int year;
    Car(String m, int y) {
        model = m;
        year = y;
    }
    void show() {
        System.out.println(model + " " + year);
    }
}

In the main method, you can create a new object using:

Car c1 = new Car("Honda", 2021);
c1.show();

In this example, we define a class 'Car' with two attributes: model and year. The constructor 'Car(String m, int y)' initializes these attributes using the values passed to it when creating a 'Car' object. In the main method of the program, we create a new instance of 'Car' called 'c1' and provide the values 'Honda' and '2021'. The 'show()' method is then called on this object to display the car's model and year.

Imagine you are customizing your dream car at an auto show. When you place your order, you select the color, type of engine, and additional features you want. The car manufacturing team then builds your car according to your specifications. In our programming example, when we create 'c1', we're essentially asking the program to build a specific car with the features (attributes) we chose.

Objects can be passed as arguments to methods:

void printStudent(Student s) {
    System.out.println(s.name + ", " + s.age);
}

And returned from methods:

Student getStudent() {
    Student s = new Student();
    return s;
}

In Java, it is possible to pass objects to methods as parameters, just like you would with basic data types. In the example 'printStudent(Student s)', the method takes a 'Student' object and prints its attributes. Also, methods can return objects. The 'getStudent()' method creates a new 'Student' object and returns it to the caller, allowing further work with that object.

Think of methods as a delivery service. You can send a package (object) to your friend (method) to deliver a message. Similarly, when you send a 'Student' object to the 'printStudent' method, it's like handing over that package so your friend can open it and read the message inside (access the object's attributes). When the method returns a 'Student', it's comparable to your friend sending back feedback or gifts to you.

An object that is used only once and does not have a reference variable is called an anonymous object.

new Student().display();

An anonymous object is an object that is created and used without assigning it to a reference variable. This means that you can use the object for actions (like calling methods) but can't directly refer back to it after its initial use. In the provided example, a new 'Student' object is created, and its 'display()' method is invoked immediately but not stored permanently in memory.

Imagine ordering a single-use coffee. When you get it, you drink it right away without taking the cup back home. By the time you're done, the coffee cup is no longer useful to you, just like an anonymous object is. You only use it once without keeping it around.

You can also create an array of objects:

Student[] arr = new Student[3];
arr[0] = new Student();
arr[1] = new Student();
arr[2] = new Student();

In Java, it is possible to create an array that holds multiple objects of the same class. Here, we create an array called 'arr' that can hold three 'Student' objects. We then instantiate three new 'Student' objects and assign them to each index of the array. This allows you to manage multiple objects conveniently through a single structure.

Consider a classroom where each student sits at a desk. The classroom itself signifies a 'Student' array, and the desks represent the indexes where individual students (objects) sit. Just like you can reach any desk to interact with a specific student, similarly, in programming, you can access any student object in the array using its index.

Objects are compared using:

• ==: compares references (memory addresses)
• .equals(): compares content (if overridden) By default, equals() behaves like ==, unless overridden.

When comparing objects in Java, the == operator checks if both references point to the same object in memory. Conversely, the .equals() method checks if the content of the objects is the same, provided it has been overridden in the class definition. If not overridden, equals() functions similarly to == and compares memory addresses instead.

Imagine two identical twin siblings. If you are comparing them based on their physical appearance (like ==), you would see the same 'object' in two places (same location in memory). However, if you ask them about their preferences or personalities (like using .equals()), they might differ despite their identical appearance. This shows that while two objects may look the same, their content could be different.

The this keyword refers to the current object. It is used to differentiate between instance variables and parameters with the same name.

class Student {
    String name;
    Student(String name) {
        this.name = name;
    }
}

The this keyword is a reference to the current object within its own class. It's particularly useful when you have parameters in a constructor or method with the same name as the instance variables. In the example, this.name distinguishes the instance variable name from the constructor parameter name, ensuring we are setting the class's attribute rather than creating a new local variable.

Think of a student introducing themselves in a large classroom. When they say, "I am Alex," it could be confusing if another 'Alex' is present. To clarify, they might say, "I, Alex (the one at the front), am here." The this keyword serves a similar purpose, making it clear which 'Alex' (or variable) they are referring to in the context of the program.

Objects that are no longer referenced are automatically deleted by the Garbage Collector in Java. This process frees up memory for new objects.

Garbage Collection in Java is an automatic memory management process that identifies and discards objects that are no longer needed. This helps in freeing up resources and memory space, allowing the application to continue functioning efficiently. Developers do not need to explicitly free memory as the Garbage Collector handles this automatically.

Imagine a library. When books are returned and not borrowed again for long periods, they are removed from the collection to make space for new arrivals. Just like that, when objects in Java are no longer in use, the Garbage Collector helps clean up to ensure the program runs smooth and efficiently.

--