In this article, we’ll be discussing meaning of method, how to call a method of different types such as instance method, static method, predefined method and more.
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();
}
}
