User-Defined Methods

A method is a named block of code within a class. It executes a defined set of instructions when called from another part of the program. The different parts of the method are access-modifier, type, method-name, parameter-list and method-body.

The method name along with the list of parameters used in the method prototype is known as method signature.

The syntax of a method definition is:

[access-modifier] type method-name (parameter-list)
{
    method-body;
}

To invoke a method, write the name of the method and specify the value of arguments of its parameter list. Below example shows the definition and invocation of a method:

public class DisplayMessageDemo {

    public void DisplayMessage() {
        System.out.println("Hello World!");
    }

    public void MyMessage() {
        DisplayMessage();
    }
}

Return statement sends back the value given to it from the called method to the caller method. It also transfers the program control back to the caller method from the called method.

void in method prototype means that the method does not return any value.

The parameters that appear in the method definition are called formal or dummy parameters whereas the parameters that appear in the method call are called actual parameters.

Static methods are created with static keyword in their method prototype as shown below:

public static return-type method-name(parameter-list)
{
    Method-body
}

Static methods can be called directly using class name but they can't access instance variables and non-static methods of the class.

The non-static methods are created without the static keyword in their method prototype as shown below:

public return-type method-name(parameter-list)
{
    Method-body
}

An instance of the class is required to call non-static methods.

In pass by reference, the reference of the actual parameter is passed to the formal parameter. Both actual parameter and formal parameter represent the same memory location so any changes made to the formal parameters get reflected in the actual parameters.

Overloading is determined based on the number and type of parameters of the method.

Sometimes there are two or more possible matches in the invocation of an overloaded method. In such cases, the compiler cannot determine the most specific match. This is referred to as ambiguous invocation. It causes a compile time error. For example, the below program will cause a compile time error due to ambiguous invocation:

public class AmbiguousDemo {

    public static double max(double num1, int num2) {
        if (num1 > num2)
            return num1;
        else
            return num2;
    }

    public static double max(int num1, double num2) {
        if (num1 > num2)
            return num1;
        else
            return num2;
    }

    public static void main(String args[]) {
        /*
         * This line will cause a compile time error
         * as reference to max is ambiguous
         */
        System.out.println(max(19, 20));
    }
}

1. double z = Check (6, 5); invokes public static double Check(int x, double y)
2. double z = Check (5.5, 7.4); invokes public static double Check(double x, double y)

Signature of this method is:

CoolMethod(int xx, char yy, int zz)

Polymorphism

public class KboatPalindromicPrime
{
    public static boolean isPrime(int n) {
        int c = 0;
        for (int i = 1; i <= n; i++) {
            if (n % i == 0) {
                c++;
            }
        }
        
        boolean prime = c == 2;
        return prime;
    }

    public static boolean isPalindrome(int n) {
        int num = n, revNum = 0;
        while (num != 0) {
            int digit = num % 10;
            num /= 10;
            revNum = revNum * 10 + digit;
        }

        boolean palin = revNum == n;
        return palin;
    }

    public static void main(String args[]) {
        int x = 1, count = 0;
        while (count < 100) {
            if (isPrime(x) && isPalindrome(x)) {
                count++;
                System.out.println(x);
            }
            x++;
        }
    }
}

2. Pure and Impure methods

3. Simple Method and Overloaded method