(a) Explain the following terms related to Java methods with the aid of suitable examples.i) Method Signature (2 Marks)ii) Method Overloading (4 Marks)iii) Call by value and Call by reference (4 Marks)

i) Method Signature: In Java, a method signature is part of the method declaration. It's the combination of the method name and the parameter list. The reason it's called a "signature" is because it's the part that's used to identify the method uniquely in its class or object. For example, in the method declaration public void add(int a, int b), the method signature is add(int, int).

ii) Method Overloading: Method overloading in Java is a feature that allows a class to have more than one method having the same name, if their argument lists are different. It is an example of compile-time polymorphism. The argument list could differ in - number of parameters, type of parameters, or the order of parameters. For example, we can have two methods named add() in a class where one adds two integers and another adds two doubles.

void add(int a, int b){
    System.out.println(a+b);
}

void add(double a, double b){
    System.out.println(a+b);
}

iii) Call by Value and Call by Reference:

• Call by Value: In this method, the value of each variable in the calling method is copied into the formal parameter of the called method. Any changes made to the parameter of the called method have no effect on the original data. For example:

void updateValue(int value){
    value = 55;
}

public static void main(String[] args){
    int value=22;
    System.out.println("Before update: "+ value);
    updateValue(value);
    System.out.println("After update: "+ value);
}

In this example, even though we change the value of 'value' in the called method, the original value of 'value' in the calling method remains unchanged.

• Call by Reference: In this method, a reference to an argument (not the actual value of the argument) is passed to the parameter. Inside the method, this reference is used to access the actual argument specified in the call. This means that changes made to the parameter will affect the passed argument. To achieve this in Java, we use object references. For example:

class Test{
    int a;
    Test(int i){
        a = i;
    }
    void updateValue(Test obj){
        obj.a += 10;
    }
}

public static void main(String[] args){
    Test test = new Test(20);
    System.out.println("Before update: "+ test.a);
    test.updateValue(test);
    System.out.println("After update: "+ test.a);
}

In this example, when we change the value of 'a' in the called method, the original value of 'a' in the calling method also changes.