Methods in Java are fundamental building blocks that allow you to encapsulate reusable code. They enable you to define a block of statements that perform a specific task, which can then be executed whenever needed. This promotes code modularity, readability, and reusability.

Consider a scenario where you need to perform the same calculation multiple times with different inputs. Instead of writing the same logic repeatedly, you can define a method.

public class AreaCalculator {

    public static void main(String[] args) {
        // Calculate area of a 5x10 rectangle
        int length1 = 5;
        int width1 = 10;
        int area1 = length1 * width1;
        System.out.println("Area 1: " + area1);

        // Calculate area of a 8x3 rectangle
        int length2 = 8;
        int width2 = 3;
        int area2 = length2 * width2;
        System.out.println("Area 2: " + area2);

        // Using a method to calculate the area
        calculateArea(5, 10);
        calculateArea(8, 3);
    }

    /**
     * Calculates and prints the area of a rectangle.
     * @param length The length of the rectangle.
     * @param width The width of the rectangle.
     */
    public static void calculateArea(int length, int width) {
        int area = length * width;
        System.out.println("Calculated Area: " + area);
    }
}

In programming, a "Method" is the term used in Java and many other languages like C#. In C and C++, the equivalent concept is called a "Function". A Java method is a collection of statements grouped together to perform an operation.

• Methods are defined within a class body. A single class can contain multiple methods.
• Methods cannot be defined inside other methods.
• The method body consists of Java statements that are executed sequentially.
• Methods are created to solve a specific type of problem.
• They are invoked (called) from other parts of the program to execute their logic.
• A method only runs when it is explicitly called.

Syntax of a Method

The general syntax for a method is as follows:

[modifiers] returnType methodName(parameterList) {
    // method body
    [return returnValue;]
}

Let's break down each component:

• Modifiers (Optional): These keywords define the access level and other properties of the method. For now, we'll use public static. When a method has the static modifier, it can be called using the syntax ClassName.methodName(arguments).
• Return Type: This specifies the type of value the method returns after execution. If a method does not return any value, the return type is void. The returned value must match the declared return type.
• Method Name: This is an identifier that follows naming conventions, typically using camelCase and starting with a verb. It should be descritpive of the method's purpose.
• Parameter List: This is a list of input values the method acccepts. Parameters are local variables defined within the method's scope. When calling the method, you provide actual values, known as arguments, which must match the parameter types and order.
• Method Body: The block of code enclosed in curly braces that contains the executable statements.
• Return Statement: The return keyword immediately terminates the method's execution. If a return type other than void is specified, a value must be returned.

Methods can also return values. Here is an example of a method that converts a temperature from Celsius to Fahrenheit and returns the result.

public class TemperatureConverter {

    public static void main(String[] args) {
        double celsiusTemp = 25.0;
        double fahrenheitResult = celsiusToFahrenheit(celsiusTemp);
        System.out.println(celsiusTemp + "°C is " + fahrenheitResult + "°F");

        // You can also use the returned value directly in another calculation
        double anotherResult = celsiusToFahrenheit(0.0);
        System.out.println("Freezing point in Fahrenheit: " + anotherResult);
    }

    /**
     * Converts a temperature from Celsius to Fahrenheit.
     * @param celsius The temperature in Celsius.
     * @return The temperature converted to Fahrenheit.
     */
    public static double celsiusToFahrenheit(double celsius) {
        return (celsius * 9.0 / 5.0) + 32;
    }
}