5 - Objects

What is an Object?

• In Object-Oriented Programming (OOP), an object is a self-contained unit that consists of both data (attributes) and the functions (methods) that operate on the data. Objects are instances of classes, which serve as blueprints or templates for creating objects.
• Every object has a state (its data), behavior (methods that define what it can do), and identity (a unique instance that distinguishes it from other objects).

How to Create an Object?

• An object is created from a class. The class defines the attributes and methods, and the object is an instance of that class.
• The new keyword in Java is used to create an object.

Syntax:
ClassName objectName = new ClassName();

Example: Creating and Using an Object in Java:

class Car {
    String color;
    String model;
    int year;
    void start() {
        System.out.println("The car is starting.");
    }
    void stop() {
        System.out.println("The car is stopping.");
    }
}

public class Main {
    public static void main(String[] args) {
        // Creating an object of the Car class
        Car myCar = new Car();
        myCar.color = "Red";
        myCar.model = "Toyota";
        myCar.year = 2021;
        // Using the object's methods
        myCar.start();
        myCar.stop();
    }
}

Constructor Methods

• A constructor is a special type of method used to initialize objects. It is called automatically when an object is created. Constructors do not have a return type, and they typically initialize the data members of the class.

Syntax:
class ClassName {
// Constructor
public ClassName() {
// Initialization code
}
}

Example of Constructor Initialization:

class Car {
    String color;
    String model;
    int year;
    // Constructor to initialize the object
    public Car(String color, String model, int year) {
        this.color = color;
        this.model = model;
        this.year = year;
    }
    void start() {
        System.out.println("The " + model + " is starting.");
    }
    void stop() {
        System.out.println("The " + model + " is stopping.");
    }
}

public class Main {
    public static void main(String[] args) {
        // Creating an object using the constructor
        Car myCar = new Car("Red", "Toyota", 2021);
        // Using the object's methods
        myCar.start();
        myCar.stop();
    }
}

What is a Method?

• A method is a function defined inside a class that describes the behavior or actions of an object. Methods perform operations using the data (attributes) of the object and can return values based on the object's state.

Syntax for Method Declaration:
returnType methodName(parameterList) {
// Method body
}

Example of Method in a Class:

class Car {
    String color;
    String model;
    int year;
    // Constructor to initialize attributes
    public Car(String color, String model, int year) {
        this.color = color;
        this.model = model;
        this.year = year;
    }
    // Method to display car details
    void displayDetails() {
        System.out.println("Car Details: " + model + " (" + year + ") - " + color);
    }
    // Method to start the car
    void start() {
        System.out.println("The car is starting.");
    }
}

public class Main {
    public static void main(String[] args) {
        // Creating an object of the Car class
        Car myCar = new Car("Red", "Toyota", 2021);
        // Calling the displayDetails method on the object
        myCar.displayDetails(); // Output: Car Details: Toyota (2021) - Red
        myCar.start(); // Output: The car is starting.
    }
}

What is the this Keyword?

• The this keyword in Java is used to refer to the current object instance. It is primarily used to distinguish between instance variables (attributes) and parameters that have the same name within a method or constructor.

Example of Using this Keyword:

class Car {
    String color;
    String model;
    // Constructor using 'this' to refer to the current object
    public Car(String color, String model) {
        this.color = color; // Refers to the instance variable
        this.model = model; // Refers to the instance variable
    }
    void displayDetails() {
        System.out.println("Car Details: " + this.model + " - " + this.color);
    }
}

public class Main {
    public static void main(String[] args) {
        // Creating an object using the constructor
        Car myCar = new Car("Blue", "Honda");
        // Using the object's method
        myCar.displayDetails(); // Output: Car Details: Honda - Blue
    }
}

Object Creation:

• Objects are created using the new keyword followed by the constructor. When an object is created, memory is allocated for the object, and its constructor is called to initialize its state.

Garbage Collection:

• In Java, when an object is no longer in use (i.e., no reference points to it), it becomes eligible for garbage collection. The Java Virtual Machine (JVM) automatically reclaims memory used by these objects to prevent memory leaks.
• Garbage Collector (GC): A part of the JVM responsible for automatically freeing memory by deleting unreachable objects.

Summary of Key Points:

• Objects are instances of classes in object-oriented programming. They have attributes (state) and methods (behavior) that define their functionality.
• Constructors are used to initialize objects with default or user-specified values.
• Methods define what objects can do and how they interact with other objects in a program.
• The this keyword helps differentiate between instance variables and parameters, and garbage collection ensures efficient memory management by cleaning up unused objects.

Practical Applications:

• Objects are fundamental in Java programming and object-oriented design. By organizing code into classes and objects, developers can create modular, reusable, and maintainable software systems.