5.7. Object as Function Arguments

Objects can be passed as arguments to methods:

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

In Java, you can pass whole objects to methods instead of just primitive data types. This means you can send a Student object to a method, which can then access the properties of that object. In the example, the printStudent method takes a Student object as an input and prints its name and age. When you call this method and provide a specific Student object, it will access that object's details and display them.

Think of this as sending a student’s report card to a teacher. Instead of just telling the teacher the grades, you give them the entire report card (the object) which contains all the information about the student's performance (name, age, grades) and allows the teacher to read it fully.

And returned from methods:

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

Methods in Java can also return objects. In the example, the getStudent method creates a new Student object and then returns it. This means when getStudent() is called, it provides us with a Student object that can be further used in the program. This allows methods to not only perform actions but also generate and provide new data (in the form of objects) back to the caller.

Imagine a factory that assembles and sends out toy cars. When you place an order, the factory creates a toy car (the object) and ships it to you. Similarly, when you call getStudent, the method creates a Student object and sends it back to you for use.

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 one that is created and used in the same line of code, and it does not have a name associated with it. In this example, new Student().display() creates a new Student object and immediately calls the display method to print its details. Since it’s not assigned to a reference variable, it cannot be accessed again, which is useful when you need an object temporarily without needing to store it for future use.

Think of ordering a coffee at a café. You order, receive your drink, and finish it right away. You didn’t set aside a special place for your coffee; you just consumed it when you got it. Similarly, an anonymous object is created for a single use and then 'consumed' instantly.

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();

Arrays can be used to hold multiple objects of the same type. In this example, Student[] arr declares an array capable of holding three Student objects. Each index of the array (0, 1, 2) can be used to hold a separate Student instance, which enables managing collections of related objects in an organized way.

Consider a classroom with a limited number of desks. Each desk can hold one student (object). By using an array of Student objects, you effectively set up a structured environment where each desk—like each index—holds one student's details, just as you would find students assigned to specific desks in a classroom.

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

When comparing objects, the == operator checks if two reference variables point to the same memory location (i.e., they are the same object). In contrast, the .equals() method is meant to compare the actual data within the objects. If not overridden, .equals() behaves like ==, but in custom classes, you could override it to compare object content instead.

Imagine you have two identical copies of a book. When you check if they are the same book (==), you’re asking if they are the exact same copy sitting on your shelf. However, if you open both and check their content (for example, the text inside), that’s like using .equals(). You can determine if the content is the same even if they are different printed copies.

this 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 keyword this is a special reference in Java that points to the current instance of the class. It is especially useful within a constructor or method when parameters have the same names as class variables. In the example, this.name = name; assigns the value of the parameter name to the instance variable name of the Student class. It helps prevent confusion between the two.

Think of a teacher addressing each student by their first name. When a teacher says, 'I will now call name in my class’ (referring to themselves), it helps clarify that they’re drawing attention to their own name without confusion. Similarly, this clarifies that an object is interacting with its own attributes, distinguishing them from any parameters that might have the same name.

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 feature. When objects are no longer referenced or used in a program, they become eligible for garbage collection, meaning they can be automatically cleaned up by the Java runtime, freeing memory resources for new objects. This prevents memory leaks and ensures efficient use of memory.

Imagine a janitor who comes into a classroom after school hours. The janitor cleans up and takes away anything that is no longer needed, such as discarded papers or lunch bags left behind by students. Similarly, the Garbage Collector removes unused objects from memory, cleaning up to ensure there is space for new information in the program.

--