5.4. Methods of an Object

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.

In object-oriented programming, methods are like actions or tasks that objects can perform. They are defined within a class and utilize the data (attributes) related to that class. When you define a method, you essentially specify what kind of operations it can do and potentially what values it can return based on the state of the object.

Imagine a smartphone. The smartphone has various functionalities like making calls, sending messages, and taking photos. Each of these functionalities can be thought of as a method. The method 'makeCall()' doesn’t just sit there; it performs an action using the phone's data, like dialing a number.

Syntax for Method Declaration:

returnType methodName(parameterList) {
    // Method body
}

The syntax for declaring a method involves specifying the return type (what type of value the method will return), the method name (which should be descriptive), and an optional list of parameters (values that can be passed into the method). Inside the curly braces, you define the body of the method which contains the actual code that will run when the method is called.

Think of the method name like a recipe title. Just as a recipe tells you what dish you will create and may include a list of ingredients (parameters), a method name indicates what action the program will perform, and the parameters tell it what information it might need to perform that action.

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.
    }
}

In this example, we have a class called Car which contains two methods: displayDetails and start. The displayDetails method prints out the details of the car, while the start method simulates starting the car. In the Main class, we create an instance of Car named myCar, and then we call both methods on this object. When methods are invoked, they perform their defined actions using the attributes of the object.

Imagine being a mechanic. When you inspect a car, you might check its color, model, and year (similar to attributes), and you have tasks like checking the engine or starting the vehicle (methods). Each task you perform is a method, and can provide details about the car (like the displayDetails method) or perform actions (like the start method).

--