Working with 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 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. Example:

public class FindSquareDemo {

    public int FindSquare(int x) {
        int result;
        result = x * x;
        return result;
    }

    public void MyFindSquare() {
        int num = 4;
        int myResult;
        myResult = FindSquare(num);
        System.out.println("Square of " + num + " is " + myResult);
    }
}

Here, variable x in the definition of FindSquare is formal parameter and variable num in the method call of FindSquare is actual parameter.

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.

Scope of the variable determines in which parts of the program the variable is accessible. It is of the following types:

1. Local Variables — The variables declared inside a method or block are called local variables. The scope of local variables is limited to the method or the block they are declared in.
2. Parameter Variables — The variables used as arguments in the method prototype are called parameter variables. Their scope is limited to the method where they are being used.
3. Instance Variables (non-static variable) — The member variables that store the state of an object are known as instance variables.
4. Class Variables (static variable) — A variable declared in a class with the static modifier is called a class variable.