What is method in Java

A method is a block of instructions(one or more line of codes) given in { } inside a class. This block is referred by a name which is basically the method name. The name of method is used to call(invoke) that method within or outside a class. Once a method is called, the code given inside that method is executed. After execution a method may or may not return a value. The most basic or minimal Syntax of declaring a method is :

 // Method without parameter
 Return_Type methodName()
   {
      // one or more line of code. 
      return some_value;
   }
   
 // Method with parameter
 Return_Type methodName(DataType param1, DataType param2 ...)
   {
      // one or more line of code. 
      return some_value;
   }             

A method must have a return type which basically tells what type of value this method returns. The Return_Type of a method can be primitive or non-primitive data type. If a method doesn't return a value, it's return type must be void or in other way if the return type of a method is void, it means that method doesn't return any value.

The name of the method is given by the programmer. As per the convention the method name should be in small letters while in multiWord method name, the first letter of any subsequent word should be in capital letter. For example method names like add(), calculateArea(), getName() etc are some examples of this convention.

After method name, it's the parameters given inside () which are basically variables. Parameters are optional which means a method may or may not have parameters. You can access these parameters within the method only, not outside the method. The data type of parameters can be primitive or non-primitive. After parameters it's method body given inside { }. Everything given inside { } after method name are the part of that method. Let's see some examples of method declaration.

 int add(int num1, int num2)
   {
      // one or more line of code. 
      return value; // returns integer value. 
   } 
    
 void calculateArea()
   {
      // one or more line of code. 
   }                 

Built-in vs. User defined methods

Methods that are defined inside the classes included in java software are known as built-in methods. For example println() method, String class methods like charAt(), toLowercase(), trim() etc are built-in methods. The methods that programmers defined inside their classes is known as user defined methods. It's programmer who gives the name to his method and code inside that method.

Parameter vs Argument

Parameters are the variables declared inside the () after the method name. These parameters can be accessed inside the method only. For example in method declaration add(int num1, int num2), variables num1 and num2 are parameters. Arguments are the values that are passed to method while calling the method. For example in a method call add(20,30), 20 and 30 are arguments.

Static and Non Static Method

A method declared with static keyword is known as static method. Static method belongs to class not object which means you don't need to create object to access such methods. You can access static methods with class name itself. Methods defined without static keyword is known as non static method, also known as instance method. You need object or instance of the class to access such methods. For example in below program calculateArea() is a static method while add(), firstMethod(), secondMethod() are non static methods.

Static method can access only static variables inside it's body while non static method can access both static and non static variables. We will discuss more about this in later tutorial.

Java Method Program

 class MethodDemo
   {
      public static void main(String [] args)
        {    
           MethodDemo md = new MethodDemo();
           int sum = md.add(20,30); // calling add() method     
           System.out.println("sum = "+sum);
           md.firstMethod();  // calling firstMethod() using object     
           MethodDemo.calculateArea(100,50);  // calling calculateArea method using className
        }
      int add(int num1, int num2)
        {
            int sum = num1 + num2;
            return sum;
        }
      void firstMethod()
        {
           System.out.println("Inside first method"); 
           secondMethod(); // calling secondMethod()
           System.out.println("After calling second method"); 
        }       
      void secondMethod()
        {
           System.out.println("Inside second method");  
        }      
      static void calculateArea(int length, int width)
        {
           int area = length*width;
           System.out.println("Area = "+area);         
        }        
   }

Output:

As you can see static method calculateArea() is called using class name MethodDemo. You can call static method using object as well, but that's not a good practice, since static methods belongs to class not object. You should always prefer to call static methods using class name.

How method execution happens in Java ?

As soon as a method is called, the execution of that method get's started. Once the execution of method completed or any return keyword encountered, the execution control comes back to the position from where it was called. Once a method is called, java creates a new stack inside stack memory where all local variables of that method are initialized.

For example in above program once line int sum = md.add(20,30); executed, the execution of add method get's started. As soon as the return statement in add method is executed, the execution control again comes back to the line int sum = md.add(20,30); where the value returned by add method is assigned in variable sum.

You can define multiple methods with same name having different parameter lists. Java differentiates such methods on the basis of the number of parameters in the list and their types. This is known as method overloading. We will discuss method overloading in later tutorials.

The syntax of declaring a method given in this tutorial is the minimal one which is required. Apart from this there are couple of more keywords as given below that can be used with method declaration. We will discuss these keywords with methods in later tutorials.

• An access modifier(public, protected, private) can also be used with method declaration. Access modifiers decides the visibility/accessibility of method within or outside the class. For example a private method can only be accessed within the class while public method can be accessed from outside the class as well.
• final keyword can also be used with method declaration. final method can not be overridden.
• abstract keyword can also be used with method declaration. The implementation or definition of abstract method is defined by sub class.
• A method can also declare an exception using throws keyword.