Functions (Methods) in Java: User-Defined

Definition:

Functions in Java (commonly referred to as methods in the context of an object-oriented programming language like Java), are blocks of code that perform specific tasks. They can be called or invoked from other parts of a program, helping to organize code into reusable modules and improve readability, modularity, and maintainability. A method can have a return type, parameters, and a body that contains the actual code to be executed.

Here is the syntax of a Java method declaration:

class ClassName
{
    static return_type MethodName(parameter1, parameter2, ...)
    {
        // Method body
        // Code to be executed
    }
}

Let's break down the different components of a Java method:

1. 'static': The term `static` indicates that the method is associated with the class itself, rather than an instance of the class. More details about objects and how to use methods through objects will be provided later in this guide.

2. Return Type: This specifies the type of data that the method will return after its execution. It can be any valid Java data type, such as `int`, `float`, `void` (indicating no return value), or even a user-defined type. For example, a method that calculates the sum of two numbers and returns the result could have a return type of `int`.

3. Method Name: This is the identifier used to call the method from other parts of the program. The method name should be meaningful and follow the naming conventions of Java. For example, a method that calculates the sum of two numbers could be named `calculateSum`.

4. Parameters: These are optional inputs to the method that allow you to pass values from the calling code into the method. Parameters are enclosed in parentheses after the method name, and multiple parameters are separated by commas. Each parameter consists of a type and a name, specifying the data type of the parameter and a local variable name to be used within the method. For example, a method that calculates the sum of two numbers could have parameters `int num1` and `int num2`.

5. Method Body: This is the block of code enclosed within curly braces `{}` that contains the actual implementation of the method. It consists of statements that define the behavior of the method. These statements can include variable declarations, control flow structures (e.g., if-else, loops), method calls, and any other valid Java code. The method body is executed when the method is called, and it can manipulate the parameters and local variables defined within the method.

Now, let's see an example of a Java method that calculates the sum of two numbers:

class Program
{
    static int CalculateSum(int num1, int num2)
    {
        int sum = num1 + num2;
        return sum;
    }
}

In this example, the method `calculateSum` takes two integer parameters `num1` and `num2`. It calculates the sum of these two numbers and stores the result in the `sum` variable. Finally, it returns the value of `sum` as the result of the method.

Calling a Method:

To call this method from another part of the program, you would simply use the method name followed by arguments enclosed in parentheses:

class Program
{
    static int calculateSum(int num1, int num2)
    {
        int sum = num1 + num2;
        return sum;
    }

    public static void main(String[] args)
    {
        int result = calculateSum(10, 20);
        // The value of result is now 30
        System.out.println("The sum is " + result);
    }
}

In this case, the method is called with the arguments `10` and `20`, and the returned value (`30`) is stored in the `result` variable.

Types of Methods:

Now, let's look at some examples of different types of methods in Java:

1. Method with no parameters and no return value (void):

static void sayHello()
{
    System.out.println("Hello, World!");
}

2. Method with parameters and a return value:

static int addNumbers(int a, int b)
{
    return a + b;
}

3. Method with parameters and no return value (void):

static void printSum(int a, int b)
{
    int sum = a + b;
    System.out.println("The sum is: " + sum);
}

4. Method with a return value but no parameters:

static double getPi()
{
    return 3.14159;
}

Method Overloading:

Method overloading is a feature in Java that allows you to define multiple functions with the same name but different parameter lists. With function overloading, you can create functions that perform similar operations but with different argument types or different numbers of arguments. The compiler determines which function to call based on the arguments provided during the function call.

Here's an example to illustrate method overloading:

class Program
{
    // Method with two integer parameters
    static int add(int num1, int num2)
    {
        return num1 + num2;
    }

    // Method with two float parameters
    static float add(float num1, float num2)
    {
        return num1 + num2;
    }

    // Method with three integer parameters
    static int add(int num1, int num2, int num3)
    {
        return num1 + num2 + num3;
    }

    public static void main(String[] args)
    {
        int sum1 = add(5, 10);             // Calls the first add method
        float sum2 = add(2.5F, 3.7F);      // Calls the second add method
        int sum3 = add(1, 2, 3);           // Calls the third add method
    }
}

In this example, the `add` method is overloaded three times. The first `add` method takes two integer parameters, the second `add` method takes two float parameters, and the third `add` method takes three integer parameters. Each method performs addition but with different parameter types or numbers of parameters.

During the method calls in `main`, the compiler determines the appropriate method to call based on the arguments provided. The first call to `add(5, 10)` matches the first overloaded `add` method with two integer parameters. The second call to `add(2.5, 3.7)` matches the second overloaded `add` method with two float parameters. The third call to `add(1, 2, 3)` matches the third overloaded `add` method with three integer parameters.