5.2. What is an Object?

An object is a real-world entity that has: • State: Represented by data or attributes (fields). • Behavior: Represented by methods (functions). • Identity: A unique address in memory.

An object can be thought of as a representation of something tangible or conceptual from the real world in programming. It encapsulates three key aspects: the state, which refers to the data or attributes that describe the object; the behavior, which consists of the methods or functions that define what the object can do; and the identity, which is the unique identifier for the object in memory. This unique address is what allows the program to distinguish between different objects.

Imagine a car. The state of the car includes its color, model, and year (attributes). The behavior might include actions like starting the engine or honking the horn (methods). Each car you see on the street can be like an object in a program since they all have unique license plates (identity) that differentiate them from one another.

In Java, an object is an instance of a class. Once a class is defined, you can create multiple objects from it, each with its own set of attributes and access to class-defined behaviors.

A class acts as a blueprint or template for creating objects. Each time you create an object from this class, you instantiate it, which means you create an actual embodiment of the concept defined by the class. Although all objects of a class share behaviors (methods), they can have different attribute values, which makes each instance unique.

Think of a class as a recipe for a cake. The recipe outlines how to make a cake (the methods), while the specific cakes you bake using that recipe can differ in flavor (the attributes). Each cake you bake using the same recipe represents a different object of the 'cake' class.

Objects in Java are created using the new keyword. The syntax is:

ClassName objectName = new ClassName();

Example:

class Student {
String name;
int age;
void display() {
System.out.println("Name: " + name);
System.out.println("Age: " + age);
}
}
public class Main {
public static void main(String[] args) {
Student s1 = new Student(); // object creation
s1.name = "Anita";
s1.age = 17;
s1.display();
}
}

To create an object in Java, you need to use the new keyword followed by the class name, which calls the constructor of the class. This allocates memory for the new object and prepares it for use. The example demonstrates the creation of a 'Student' object, where we set attributes like 'name' and 'age' and then call the 'display' method to print out these values.

Imagine you are ordering a custom-made phone. The blueprint of the phone represents the class. When the manufacturer uses the blueprint to create a specific phone for you, that phone becomes an object. Using the new keyword is like telling the manufacturer to start the process of building your phone.

Members of an object (fields and methods) are accessed using the dot operator (.). Example:

s1.name = "John";
s1.display();

After creating an object, you can access its members (both fields and methods) using the dot operator. This operator allows you to reference specific attributes or invoke methods on an object. In the example provided, we assign a new name to the 'Student' object and call the 'display' method to show the updated information.

Think of an object as a person; the dot operator is like pointing at that person to indicate what you want. When you say 'John.name', it's like saying 'Hey, John, what’s your name?', and 'John.display()' would be akin to asking John to tell you about himself.

A reference variable is used to refer to an object. It holds the memory address of the object.

Student s1 = new Student(); // 's1' is the reference variable

In Java, a reference variable serves as a pointer to an object. Instead of holding the actual data of the object, it holds the memory address where the object is stored. This allows multiple reference variables to point to the same object, enabling shared access to the object's data and methods.

Consider a library where the reference variable is like a library card that tells you where to find a specific book. The book exists at a particular shelf (memory address), and every time you show your library card, you can access that same book regardless of how many times you check it out.

--