Schedule a consultation and Hire a Java Developer

To hire the best Java developer for your project or team, you need to make sure they have the ability to solve complex issues using java. We suggest asking the prospective developer questions about how they would solve specific problems. For example a experienced java developer should be able to call a method in Java. Read below to learn what it means to call a method in Java.

Before delving into how methods can be created, there is a need to understand the meaning of methods. A method is a block of code that is executed only when called. You can put data called parameters into the pattern. Methods are used to perform specific operations and are also called functions. It is generally used because it offers code reuse, which means it is written once and used at different times. It also offers simple changes. Each method features a unique name you can use when calling them. After reading the method name through the compiler, the method is called, and the specified task is performed. In this article, you will learn how to call predefined, custom (user-defined), static, and abstract methods in Java.

Calling Static Method in Java

In Java, a static method is a method that is called or invoked without a need to create a class object that defines the method. In addition, we can create static methods by putting the static keyword ahead of the method name. We can also create static methods using the static keyword before the method name. We can use ClassName.methodName to call static methods. The best illustration for a static method is the main() method. You can call it without object creation. In the code below, the static method of the Math class has been called. It is known as min(), and it returns at least the value of two numbers.

StaticMethodCallExample.java

import java.util.*;
public class StaticMethodCallExample {
public static void main(String args[]) {
int a;
//calling static method of the Math class
a = Math.min(40,98);
System.out.println("Minimum number is: " + a);
}
}

Output: The minimum number is 40.

Calling the Pre-Defined Method in Java

Pre-defined methods are methods that have been defined already in the classes. When you need any pre-defined methods, you can just call its name. In the illustration below, a class object called hashCode() was used. In the following example, we have used a method named hashCode() of the class Object. To call the hashCode () predefined method, we create an object obj for the object class because it is an Object class method. When we use an object, we called the hashCode() method, which returns the value of the hash code for the object.

PredefinedMethodCallExample.java

public class PredefinedMethodCallExample {
public static void main(String[] args) {
int a;
Object obj=new Object();
a=obj.hashCode();
System.out.println("Hash Code of the object is: "+a);
}
}

Output: Hash Code of the object is: 2036368507

Calling User-Defined Method in Java

To call a custom (user-defined) method, we first create a method and then call it. You must create a method in the class with parentheses () after the method name. The definition of a method consists of the header and body of the method. You can call a method using the commands below.

method_name(); //non static method calling

If the method is a static method, use the command below:

obj.method_name();
//static method calling

Where obj is the object of the class. In the illustration below, two user-defined methods were created; showMessage() and displayMessage(). They are both static (showMessage()) and non-static method (displayMessage()). You should also note that the showMessage() method was called directly without an object. And the displayMessage() method is called through the class object.

MethodCallExample.java

public class MethodCallExample {
//user-defined static method
static void showMessage() {
System.out.println("The static method invoked.");
}
//user-defined non-static method
void displayMessage() {
System.out.println("Non-static method invoked.");
}
public static void main(String[] args) {
//calling static method without using the object
showMessage(); //called method
//creating an object of the class
MethodCallExample me=new MethodCallExample();
//calling non-static method
me.displayMessage(); //called method
}
}

Output: The static method invoked. Non-static method invoked.

It can happen that we have a class with methods that has the same name. So, how do we call two methods that have the same name? If a class with the same name has two or more methods, a distinction is made using the return type, parameter type, or a number of parameters. This concept is known as method overloading.

int sum(int x, int y);
double sum(double x, double y);

The two methods above contain the same name as sum() but are different. The first sum() returns an int value and parses two parameters which are integers x and y. At the same time, the second sum() returns a double value and parses two parameters which are two double values, a and y. The program below overloads sub() method

MethodOverloadingExample.java

public class MethodOverloadingExample {
static int sub(int x, int y) {
return x - y;
}
static double sub(double x, double y) {
return x - y;
}
public static void main(String[] args) {
int a = sub(50, 20);
double b = sub(45.42,20.7);
System.out.println("subtraction of integer values: " +a);
System.out.println("subtraction of double values: " +b);
}
}

Output: Subtraction of integer values: 30. Subtraction of double values: 24.720000000000002

Calling Abstract Method in Java

An Abstract method is a method that has an abstract keyword declaration. An abstract method has only one method declaration. Abstract body method defined in another class. The abstract methods must be stated in abstract classes. We can define the visibility of abstract methods as private or public methods. Abstract methods cannot be declared as final as that outweighs the benefits of abstract methods. The actual application of the abstract method must be in the subclass. The abstract method can be defined as follows:

abstract public void findArea();

Let us create a program that calls the abstract method. In the example below, we create a class called AbstractMethodExample, which is declared as an abstract class. In this class, we declare an abstract method called show(). Next, we create another class called AbstractMethodCalling, which is an extension of the AbstractMethodExample class. In this class, abstract methods are being implemented. We created a parent class and invoked the abstract method to call the show().

AbstractMethodCalling.java

//abstract class
abstract class AbstractMethodExample {
//abstract method declaration
abstract void show();
}
public class AbstractMethodCalling extends AbstractMethodExample {
//abstract method implementation
void show() {
System.out.println("The abstract method called.");
}
public static void main(String args[]) {
AbstractMethodExample obj = new AbstractMethodCalling();
//calling abstract method
obj.show();
}
}

Output: The abstract method is called.