User-Defined Methods

A function is a named block of code within a class. It executes a defined set of instructions when called from another part of the program.

A function is also known as a member method.

A method/function prototype is the first line of the function definition that contains the access specifier, return type, method name and a list of parameters.

The parameters that appear in the method call statement are called actual parameters.

The parameters that appear in the method definition are called formal parameters.

For example,

class ParameterDemo  
{
    double square(double x)    {
        return Math.pow(x,2);
    }
    
    public static void main(String args[])
    {
        ParameterDemo obj = new ParameterDemo();
        double n = 5.3;
        double sq = obj.square(n);
    }
}

Here, x is the formal parameter and n is the actual parameter.

The statement that invokes a function is called method call statement.

False.

Reason — A function argument is the value passed to the function by the method call statement at the time of method call. The value returned by the function is called the return value of the function.

A function can return only one value because as soon as return statement is executed, the execution of the method terminates and control is transferred to the method call statement.

The condition of using a function in an expression is that it must return some value. The return type of the function should not be void.

True

Example —

class Demo
{
    int sum(int a, int b)   {
        int sum = a + b;
        return sum;
    }

    public static void main(String args[])  {
        Demo obj = new Demo();
        int ans = obj.sum(10, 20);
        System.out.println(ans);
    }
}

The data type of arguments a and b is not specified.

The prototype of the function must specify the data type of the formal parameters. The correct statement is as follows:

float average (float a, float b) { }

The data type of argument y is not specified.

The prototype of the function must specify the data type of the formal parameters. The correct statement is as follows:

float mult (int x, int y) { }

Assignment is not allowed in function prototype. The argument list must contain the data type along with the variable name. The correct statement is as follows:

float doer (int n, float pi) { }

The principal reason for passing arguments by value is that the actual parameters that are used to call the method cannot be modified by the called method because any changes that occurs inside the method is on the method's copy of the argument value. The original copy of the arguments remains intact.

the function accesses the argument's original value in the calling program.

Reason — In call by reference, the called method does not create its own copy of original values, rather, it refers to the original values through the references. Thus, the called method works with the original data and any change in the values gets reflected to the data.

The principal reason for passing arguments by reference is that we want the modifications done by the called method to reflect back to the original variables (i.e., actual parameters). For example, a method that swaps the values of two variables. In this case, we will pass an object containing the two integers to the method so that the swapped variables are visible in the calling method.

The reference data types — objects and arrays, are passed by reference.

The return statement is useful in two ways:

1. As soon as a return statement is encountered, the control is returned to the calling method.
2. It is used to return a value to the method call statement.

The three types of functions in Java are-

1. Computational methods — The methods that calculate or compute some value and return the computed value. Computational methods always return a computed result. For example, Math.sqrt( ) and Math.cos( ).
2. Manipulative methods — The methods that manipulate information and return a success or failure code. Generally, if value 0 is returned, it denotes successful operation; any other number denotes failure.
3. Procedural methods — The methods that perform an action and have no explicit return value. For instance, System.out.println() method is a procedural method.

Polymorphism is the property by which the same message can be sent to objects of several different classes and each object can respond in a different way depending on its class.

In function overloading, a function name has several definitions in the same scope. These function definitions are distinguished by their signatures. The same function behaves differently with different number and types of arguments.

Let us consider the given example in which the function perimeter() is overloaded. In each function, the perimeter of a different shape (square, rectangle and trapezium) is calculated.

public class Perimeter
{
    public double perimeter(double s)
    {
        double p = 4 * s;
        return p;
    }
    
    public double perimeter(double l, 
                            double b)
    {
        double p = 2 * (l + b);
        return p;
    }
    
    public double perimeter(double a, 
                            double b, 
                            double c, 
                            double d)
    {
        double p = a + b + c + d;
        return p;
    }
}

Thus, overloading implements polymorphism.

A function name having several definitions in the same scope that are differentiable by the number or types of their arguments, is said to be an overloaded function. The process of creating overloaded functions is called function overloading.

The significance of function overloading in Java is as follows:

1. It implements the object oriented concept of Polymorphism.
2. It reduces the number of com­parisons in a program and thereby makes the program run faster.

The key to function overloading is a function's signature. The signatures can differ in the number of arguments or in the type of arguments, or both. To overload a function name, we need to declare and define all the functions with the same name but different signatures, separately.

At the time of function call, the compiler matches the signature of overloaded function with the signature of the method call statement and executes the function with the matching signature.

The following factors make two definitions with the same function name significantly different:

1. The number of arguments
2. The type of arguments

Sometimes, there might be ambiguity between float and double values or int or long values.

For instance, if you want to invoke the function with following declaration: void prnsqr(double d) with the value 1.24. This value may also be assumed to be float as well as double.

To avoid such ambiguity, we can use constant suffixes (F, L, D, etc.) to distinguish between such values as these greatly help in indicating which overloaded function should be called.

An ordinary floating constant (312.32) has the double type, while adding the F suffix (312.32 F) makes it a float. The suffix L (312.32L) makes it a long double. Similarly, suffix D or d makes it a double.

False

Reason — Two or more methods can have the same name in Java if the functions are overloaded. For function overloading, many function definitions can have the same name but they must have different signatures.

False

Reason — We can't overload methods with differences only in their return type. The methods must have distinct signatures as well.

True

Reason — The data members declared as 'private' can only be accessed by the member methods of the same class.

True

Reason — A method declared as static can only access static class members.

False

Reason — A method declared as static can be invoked by using the syntax <class name>.<method name>. For example, in Math.pow() function, Math is the name of the class and pow() is its static function.

1. int sum(int x, int y, int z) { }
2. int sum (float x, float y) { }
3. float sum(int x, int y, float z) { }

Reason — Function prototypes 1,3 and 5 have different signatures. Thus, they are overloading the function sum(). Prototypes 2 and 4 have same signatures as both are taking two int arguments, which will generate compile time error.

The keyword 'void' signifies that the method doesn't return a value to the calling method.

In call by value, the called function creates its own work copy for the passed parameters and copies the passed values in it. Any changes that take place remain in the work copy and the original data remains intact.

In call by reference, the called function receives the reference to the passed parameters and through these references, it accesses the original data. Any changes that take place are reflected in the original data.

This can be clearly understood by the example given below:

public class DemoFnCalls
{
    public static int x = 10 ; 
    public static int y = 20 ;
    
    public void DemoTest()  {   
        System.out.println("Values initially. x =" + x + ",  y =" + y);
        swapCallByValue(x, y);
        System.out.println("Values after swapCallByValue method. x =" 
                                + x + ", y =" + y) ;
        DemoFnCalls object1 = new DemoFnCalls( ) ; 
        swapCallByRef(object1);
        System.out.println ("Values after swapCallByRef method. x ="
                                + x + ", y =" + y) ;
    }

    public static void swapCallByValue(int a, int b)  {	  
        int tmp;	
        tmp = a;
        a = b;
        b = tmp;
        System.out.println("Values inside swapCallByValue method. x =" 
                                + a + ", y = " + b);
    }

    public static void swapCallByRef(DemoFnCalls obj)   {
        int tmp;
        tmp = obj.x; 
        obj.x = obj.y; 
        obj.y = tmp;
        System.out.println("Values inside swapCallByRef method. x =" 
                                + obj.x + ", y =" + obj.y);
    }
}

The program has a syntax error in the chg method parameter definition. The correct syntax would be public static void chg(String nm), without the parentheses around nm.

Assuming this error is fixed, then the output of the program will be as follows:

Julius 
Julius

Explanation

In Java, String objects are treated differently because String objects are immutable i.e., once instantiated, they cannot change. When chg(name) is called from test() method, name is passed by reference to nm i.e., both name and nm variable point to the same memory location containing the value "Julius" as shown in the figure below:

Inside chg() method, when the statement nm = "Aamna" ; is executed, the immutable nature of Strings comes into play. A new String object containing the value "Aamna" is created and a reference to this new object is assigned to nm as shown in the figure below:

The variable name still holds the reference to the memory location containing the value "Julius". After chg() finishes execution and control comes back to test() method, the value of name is printed as "Julius" on the console.

The compiler interprets more than one definitions having same name by matching the signature in the function definitions with the arguments given in the method call statement.

When a function name is declared more than once in a program, the compiler will interpret the second and subsequent declarations as follows:

1. If the signatures of subsequent functions match the previous function's, then the second is treated as a re-declaration of the first and is flagged at compile time as an error.
2. If the signatures of the two functions match exactly but the return types differ, the second declaration is treated as an erroneous re-declaration of the first and is flagged at compile time as an error. For example:
   float square(float f) {...} and double square(float x) will be treated as an error.
   Functions with the same signature and same name but different return types are not allowed in Java. We can have different return types, but only if the signatures are also different :
   float square (float f) and double square (double d)
3. If the signatures of the two functions differ in either the number or type of their arguments, the two functions are considered to be overloaded.

When an overloaded function is called, the compiler matches the signature in the function definitions with the arguments given in the method call statement and executes the function once the match is found.

To avoid ambiguity, we can use constant suffixes (F, L, D, etc.) to distinguish between values passed as arguments. These greatly help in indicating which overloaded function should be called. For example, an ordinary floating constant (e.g., 312.32) has the double type, while adding the F suffix (e.g., 312.32 F) makes it a float.

For example, the following code overloads a function perimeter() which calculates the perimeter of square, rectangle and trapezium.

public class Perimeter
{
    public double perimeter(double s)
    {
        double p = 4 * s;
        return p;
    }
    
    public double perimeter(double l, 
                            double b)
    {
        double p = 2 * (l + b);
        return p;
    }
    
    public double perimeter(double a, 
                            double b, 
                            double c, 
                            double d)
    {
        double p = a + b + c + d;
        return p;
    }

    public static void main(String args[])  {
        Perimeter obj = new Perimeter();
        double areaSquare = obj.perimeter(5.8);
        double areaRectangle = obj.perimeter(10.5, 4.5);
        double areaTrapezium = obj.perimeter(4, 10, 7, 15);
        System.out.println(areaSquare + " " 
                            + areaRectangle + " " 
                            + areaTrapezium);
    }
}

Output

23.2 30.0 36.0

The given code generates an error due to wrong method prototype — public static void check int k ;

The correct syntax of the method will be —

public static void check (int k)

Assuming the method prototype was correct, the following output will be generated:

m + n = 1030
m is 5
n is 5
x = 15

Explanation

Initially, m = 10 and n = 30.

The value 5 is passed by value to the function check(). The function check() declares a local variable m whose value is 5. The value of n is modified to 5. Both the values (m and n) are printed and then the control goes back to the statement following the method call.

The value of x becomes 15 (since m = 10 and n = 5). Inside the main(), the value of local variable m is 10 and n is 5.

The given code generates error because of the following :

1. String s is already declared in the function signature. Its redeclaration inside func() will cause a compile time error.
2. String s1 is not declared and that is also a compile time error.

In Java, methods reside in classes.

The number and type of arguments of a function are known as function signature.

The first line of function definition that tells about the type of return value along with number and type of arguments is called function prototype.

void

Reason — If no value is being returned, the return type of a function is void.

1

Reason — In Java, a function can return only a single value.

actual parameters

Reason — The parameters that appear in method call statement are called actual parameters.

formal parameters

Reason — The parameters that appear in method definition are called formal parameters.

Call by Value

Reason — In Call by Value, the data of actual parameters is copied into formal parameters. Thus, actual parameters remain unchanged.

Call by Reference

Reason — In call by reference, the called method does not create its own copy of original values, rather, it refers to the original values through the references. Thus, the called method works with the original data and any change in the values gets reflected to the data.

impure function

Reason — An impure function is the function that changes / modifies the state of received argument.

function overloading

Reason — The process of creating overloaded functions i.e., one function with different signatures, is called function overloading.

it offers mathematical solutions of problems

Reason — A function helps cope up complexity in programs, makes subprograms reusable and hides the implementation details. It does not offer mathematical solutions of problems.

The keyword 'return' causes the control to transfer back to the method call.

The keyword 'void' indicates that a method has no return type.