What is a Method ?

A method is a block of code that performs a particular task.  It can be invoked anywhere in a program . It increases code readability and reusability.

When a compiler encounters a method name, it executes its body. After finishing the method execution, the control is sent back to the caller method’s immediate next statement.

How to create a method in java? 

In order to create a method, the below syntax should be considered :

public static void methodName(int x, int y) {
   // body
}

• public : access modifier
• static : non-access modifier
• void : return type
• methodName : name of the method
• int x, int y : method arguments or parameters

A method can be divided into two parts : method header and method body, method header is like signature with description which is defined at very beginning, and method body is, where your logic resides.

For example : 

void sum(int a, int b){   // method header
   int result = a + b;                   // method body
  System.out.println("Sum : "+ result);
    
}

How to Call a Method in Java ?

Calling method using object or calling an Instance method

An instance method is a method that requires an object in order to get called. In other words, we need to create an object of a class in which the method resides and then using the object name followed by dot operator, we can call it.

Syntax:

ObjectName.methodName();

Program:

public class InstanceMethodExample {

private void getMessage(){
System.out.println("Hi this is an example of Instance withod ");
}

public static void main(String[] args) {
InstanceMethodExample obj = new InstanceMethodExample();
obj.getMessage();
}
}

Explanation:

In the above code, we defined an instance method to print a simple message. In main(), we first created the object in which the method was defined  and then after we invoked it using “obj” object.

Calling a Static method

A static method is a method that doesn’t depend on the object of a class in which it resides. It uses static keyword before return type while declaration. In Java, main() is a good example of a static method.

Syntax:

ClassName.methodName();

Program:

public class StaticMethodExample {

private static void getMessage(){

System.out.println("Hi this is an example of Static method ");

}

public static void main(String[] args) {
StaticMethodExample.getMessage();
}
}

However, when we are calling it from the same class, we don’t mandatorily to put className.

Explanation:

In the above code, we defined a static method to display a message. In main(), we are directly calling it without using any object.

Calling pre-defined Method in Java

In Java, standard libraries provide helpful predefined methods. In other words, these are prewritten classes consisting of utility methods, for example, the String class offers methods like trim(),toLowerCase(). These classes can be imported and directly used in our program without the need to write them from Scratch.

If a method in the utility class is an instance method then we would call it ObjectName.methodName(). In case of static, ClassName.methodName();

Program:

class PreDefinedMethodExample {


public static void main(String[] args) {
String str = " Called my utility method ";

System.out.println(" Lower Case : "+str.toLowerCase());
}
}

Explanation:

In above code, we are importing String Class and using the method name toLowerCase() which converts a string to lower-case in our code.

Calling an Abstract Method

A method defined with abstract keyword is termed as Abstract method. It comes with only declaration part and the body is provided by the implementing or child class. In this, the concept of inheritance is come into picture.

An abstract method is defined in an abstract classes and another class that extends it would need to implement its abstract method.

Syntax:

abstract returnType methodName();

Program :

public abstract class AbstractClassExample {

abstract void getMessage();
}


class ChildClass extends AbstractClassExample{
@Override
void getMessage() {
System.out.println("Defining Abstract class method");
}

public static void main(String[] args) {
ChildClass obj = new ChildClass();
obj.getMessage();
}
}

The main difference is, Function Overloading enables us to define multiple functions with a similar name within the same class, whereas Function overriding allows us to redefine a method having same name and signature in inheriting class.

Difference between Function Overloading and Function Overriding in Tabular form :

Function Overloading

Function overloading is a form of static polymorphism where at least two functions can have a similar name with different arguments and can be considered as an instance of polymorphism.

In other words, functions with a similar name but having a different number of parameters or types of arguments are said to function overloading.

A compiler calls correct function out of others on the basis of their number of parameters or datatypes in arguments.

However, changing only the return type of the function and keeping parameters and other aspects the same would make compiler confuse in choosing the correct function.

Function Overriding

Function overriding is a form of dynamic polymorphism that enables us to have an equivalent function in child class which is already defined in the parent class.

A child class acquires member variables and member functions of its parent class. When there is a need to override the functionality of the parent’s member function then we use the concept of function overriding.

It resembles making another adaptation of an old method, in the child class.

If we talk about C++, a virtual keyword or non-virtual way (without writing the virtual keyword in front of function) in order to achieve function overriding.

C++ program to show Function Overloading :

#include <iostream>
using namespace std;
class Shape{
public:
// area() function to calculate area of square
void area(int side) 
{
  cout<<"Area of square :"<< side*side;
}
// Overloading area() function to calculate area of rectangle
void area(int len, int width)
{
  cout<<"Area of Rectangle :"<< len * width<<"\n";

}

};
int main() {
   Shape obj;
   	cout<<"Example of function overloading \n";
    obj.area(10);  // Calling it to calculate square area
    	cout<<"\n";
    obj.area(5,10);  // Calling it to calculate rectangle area
    return 0;
}

Output:

Area of square :100                                                                                                 
Area of Rectangle :50

Explanation: 

Here in the above example, area function was overloaded, one for calculating square’s area and the second one for calculating the rectangle’s area.

C++ program to show Function Overriding:

#include <iostream>
using namespace std;
// Parent class
class Shape{
public:
void display(){
cout<<" I am base class";	
}

};
// Child Class
class Rectangle: public Shape
{
  public:
void display(){
  cout<<"I am overriding display function of parent class \n";
}
};
int main() {
   Rectangle obj;
   	cout<<"Example of function overriding \n";
    obj.display();
    return 0;
}

Output:

Example of function overriding 
I am overriding display function of parent class

Explanation: 

Here, we overrode the display method, enabling us to define or redefine the body of that function in the child class.

[Related Article: Difference between method overloading and method overriding in Java]