Create and call a method in Java: How to use methods in Java

This article will explain how you can create and call a method in Java; in other words, how to use a method in Java. We will see several examples of using methods to form a more extensive program by creating several small methods.

How to use a method in Java?

When you want to use a method, it’s called that you call that method. To call a method, you enter the method name, followed by any input parameters. When an input parameter is passed to the method, it is denominated as an argument.

Therefore, to call a method in Java, we write:

• Start with the name of the method.
• Followed by the arguments to the method in parentheses. If the method requires several arguments, we separate them with a comma (input1, input2, input3, etc.). Additionally, if the method don’t have any input arguments you simply leave the parentheses empty. 
• End with a semicolon.

Syntax: Use a method in Java

If we enter the elements in the list above in the code editor

methodName (input parameters);

Input parameters for a method in Java

When we pass an input parameter to a method, it is called an argument. Moreover, when working with multiple parameters, the method call must have the same number of arguments as there are parameters in the method, and the arguments must be passed in the same order. 

For example, if you have the method below

public static void exMethod (int a, String b, double c){

}

All arguments into the method must be declared and in order int, String and double. Similarly, if the method has no input parameters, we can, of course, not specify any.

Therefore, if our method does not require any input arguments we simply leave the parentheses empty

// No input arguments to the method 
public static void exTwoMethod (){

}

Dividing a complex problem into smaller parts makes your program clear to understand and reusable.

Assign values from what a method returns to a variable

If the method returns a value, you can assign this to a variable of the same data type. Therefore, if we have a method that returns something and want to save it in a variable, we declare: 

// Assign the values that the method returns to a variable
datatype variableName = methodName (input parametrar);

Important to pay attention to the data type that the method returns. Remember, if we want to save values in a different data type than the method returns, we can use type conversion to convert our data type to a suitable type. 

Examples: Create and call methods in Java

Now we’ve seen how to create and call methods in Java, but let’s take a couple of examples to use what we have learnt.

Example 1: Call a method in Java

Let’s start with a simple example. Below we have created a method named my_method. We have specified that my_method should return an int and have two input parameters, num1 and num2, of data type int. Additionally, the method performs a multiplication between num1 and num2 and then return the value.

public class Exempel {

    // Method that multiply two numbers
    public static int my_metod(int num1, int num2){ 
        return num1 * num2;
    }
}

Furthermore, if we illustrate the method 

We can now call the method by using the name of the method:

public class Exempel {

    // Method that multiply two numbers
    public static int my_metod(int num1, int num2){ 
        return num1 * num2;
    }

    public static void main(String[] args) {
        int a = my_metod(5, 4);
        
        // Uses the method and prints the answer
        System.out.println("Result from my_method: " + a);
    }
}

In this case

• We declare a variable of data type int name  a. The variable a will be assigned the value returned from the method. 
• Our input parameters to the method are the value 5 and 4 where the variable num1 will have the value 5, and the variable num2 will have the value 4. The input parameters to the method are assigned in the same order as you specify them when declaring the method.
• The method returns the multiplication between num1 and num2. If we print the value of a, we will thus get the result 20.

Let’s try a few more cases.

public class Exempel {

    // Method that multiply two numbers
    public static int my_metod(int num1, int num2){ 
        return num1 * num2;
    }

    public static void main(String[] args) {
        int a = min_metod(5, 4);
        int b = min_metod(3, 2); 
        int c = min_metod(1, 8);
        
        // Uses the method and prints the answer
        System.out.println("Result a from my_method: " + a);
        System.out.println("Result b from my_method: " + b);
        System.out.println("Result c from my_method: " + c);
    }
}

If we run our program we get the result

Result a from my_method: 20
Result b from my_method: 6
Result c from my_method: 8

If you want to try the example above, use the button below to try it online.

Example 2: Create and use multiple methods in Java

In this example, we will programme a calculator that keeps track of how many people are inside a store (a very relevant use during the Covid-19 pandemic). Furthermore, we will use the built-in scanner class to gather information from the user.

Let’s start with a straightforward method, all it has to do is add one person

// Increase the variable nmbrOfPeople by one
public static void increaseValue(){     
    nmbrOfPeople++;                     
}

Similarly, we create a method that will remove a person

// Reduces the nmbrOfPeople variable by one
public static void decreaseValue(){     
    nmbrOfPeople--;                    
}

Additionally, we also want a method that returns the value of nmbrOfPeople

// Returns the value of nmbrOfPeople
public static int getNmbrOfPeople(){     
    return nmbrOfPeople;               
}

Moreover, we also write a method that asks the user questions. If the user writes “INCR“, the number of people in the store will increase. Correspondingly, if the user writes “LOW“, the program should lower the number of people in the store. 

// This method returns the input from the use
// In this case, a String is returned
public static String getInputsFromScanner() {  
    
    String name; 
 
    // Asking the user to increase or decrease
    System.out.println("Type INCR if you want to increase the number " +   
            "people, or type LOW to reduce the number of people");

    // Create a scanner object
    Scanner input = new Scanner(System.in);
    
    // Save the input from the user
    name = input.nextLine();  
    
    // The method return the variable name
    return name;     
}

Finally, let’s combine all the methods to build our program

//Import the Scanner class
import java.util.Scanner;                   

public class Counter {  
    //Creates the variable nmbrOfPeople                
    public static int nmbrOfPeople = 0;     

    // Increase the variable nmbrOfPeople by one
    public static void increaseValue(){     
        nmbrOfPeople++;                    
    }

    // Reduces the nmbrOfPeople variable by one
    public static void decreaseValue(){     
        nmbrOfPeople--;                     
    }

    // Returns the value of nmbrOfPeople
    public static int getNmbrOfPeople(){    
        return nmbrOfPeople;                
    }

    public static String getInputsFromScanner() {     
        String name; 

        System.out.println("Type INCR if you want to increase the number " +   
            "people, or type LOW to reduce the number of people");
    
        Scanner input = new Scanner(System.in);
        name = input.nextLine();  
    
        return name;     
    }

    public static void main(String args[]) {

       // Boolean variable to control the loop 
       boolean runProg = true; 

       //The loop run while runProg is true
       while(runProg) {                            
           
           // The getInputsFromScanner method returns the value of
           //what the user enters and saves it in str
           String str = getInputsFromScanner(); 

           // If user typed "INCR", the increaseValue method should run
           if (str.equals("INCR")) {             
                increaseValue();
           }

           // If user typed "LOW", the decreaseValue method should run
           else if (str.equals("LOW")){        
               decreaseValue();
           }

           // If the user entered "QUIT", the loop should end
           else if(str.equals("QUIT")){
                System.out.println("The program ends");
                runProg = false;
            }

           //If the user entered incorrect input
           else{
                System.out.println("Incorrect input, try again");
            }

           //Finally, we show the number of people in the store
           System.out.println("Number of people in the store: " + getNmbrOfPeople());   
       }
    }
}

To conclude, we have used several different methods to create a full program. Small building blocks together create big programs. Therefore, make your methods as general and useful as possible so that you can reuse them as many times as possible. 

Example 3: Calculate the volume of a cone and a pyramid

Our third and final example will be perhaps a bit longer, but let us take it step by step. Our third and final example will be perhaps a bit longer, but let us take it step by step. In this example, we will use methods to write a program that calculates the volume of a cone and a pyramid. The program should then determine which of the cone or pyramid has the largest volume. Additionally, we will use JOptionPane to create dialogue boxes that will interact with the user. 

Calculate the volume of a cone

Calculate the volume of a pyramid

Create a Java method that calculates the area of a circle

Let’s start by creating a method, areaCircle, that calculates the area on a circle, in other words, the cone’s base area. The method has a data type double as an input parameter and should also return a double.

public static double areaCircle(double radius) { 

    // Calculate the area of a circle
    double area = radius*radius*Math.PI;      
    return area;                              
}

Create a Java method that determines the base area of a pyramid

Similarly, we create a method, areaPyramid, that calculates the base area for the pyramid. Note that areaPyramid takes two input parameters of data type double and that the method also returns a double

public static double areaPyramid(double length, double width ) { 

    // Calculate the base area of pyramid
    double areaTriangle = length*width;                          
    return areaTriangle;                                        
}

Declare a method that computes the volume of a pyramid and a cone

Furthermore, since the formula for calculating the volume is the same on both the cone and the pyramid – we can use the same method. Therefore, we do not need to write one method for the cone and one for the pyramid. Instead, we use the same method. 

We create a method named volume which also takes two values (area and height) and then returns a data type variable double.

public static double volume(double area, double height) {  

    // Calculate the volume
    double volume = area * height; 
    return volume;   
}

Create a method in Java that compares and determines the largest volume

Furthermore, to distinguish which of the volumes that is the largest, we will create a method named largestVolume. Note that the method largestVolume returns a String. 

public static String largestVolume(double volumeCone, double volumePyramid){

    // Evaluate if the cone's volume is larger than the pyramid's
    if(volumeCone > volumePyramid){  
        return "The cone has the largest volume";
    }

    // Evaluate if the cone's volume is smaller than the pyramid's  
    else if(volumeCone < volumePyramid){
        return "The pyramid has the largest volume";
    }

    // Else, the volumes must be the same size 
    else{ 
        return "The volumes are the same size";  
    }
}

Receive input to the program with JOptionPane

Finally, we create a method that receives the pyramid’s length and height and the cone from the user by utilising the JOptionPane class. The method is named getInputsFromJOptionPane and should not return any value (void), nor should the method receive any input parameters.

public static void getInputsFromJOptionPane() {        

     // Saves the value that the user enters in a dialog box 
    // Double.parseDouble exists so that the value entered is a double              
    double radiusCone = Double.parseDouble(JOptionPane.showInputDialog(null, "Enter the radius of the cone"));   
    double heightCone = Double.parseDouble(JOptionPane.showInputDialog(null, "Enter the height of the cone"));
    double lengthPyramid = Double.parseDouble(JOptionPane.showInputDialog(null, "Enter the length of the base of the pyramid"));
    double widthPyramid = Double.parseDouble(JOptionPane.showInputDialog(null, "Enter the width of the base of the pyramid"));
    double heightPyramid = Double.parseDouble(JOptionPane.showInputDialog(null, "Enter the height of the pyramid"));

    // Use the areaCircle method to calculate the area. Submits the value of radiusCone.
    // The value returned from the method is saved in areaOfCone
    double areaOfCone = areaCircle(radiusCone);                       

    // Use the method volume to calculate the volume of the cone. Submits the value of areaOfCone and heightCone.   
    double volumeCone = volume(areaOfCone, heightCone);               

    // Use the areaPyramid method to calculate the area. Submits the value of lengthPyramid and widthPyramid.   
    double areaOfPyramid = areaPyramid(lengthPyramid, widthPyramid);  

    // Use the volume method to calculate the volume of the pyramid. Submits the value of areaOfPyramid and heightPyramid.
    double volumePyramid = volume(areaOfPyramid, heightPyramid);      

    // Determine volume is largest using the largestVolyme method.
    String largestVolume = largestVolume(volumeCone, volumePyramid);  

     // Prints the largest value in a dialog box
    JOptionPane.showMessageDialog(null, largestVolume);
}

The entire code to calculate the volume of a cone and a pyramid

To conclude, if we merge the code from all the previous steps with associated explanatory comments, we get: 

 //Import the class JOptionPane
import javax.swing.JOptionPane;

public class Volume {
    public static void main(String args[]) {

         // This is where the code starts. 
         // The getInputsFromJOptionPane method is executed first
        getInputsFromJOptionPane();
    }

    public static double areaCircle(double radius) { 
        // Calculate the area of a circle
        double area = radius*radius*Math.PI;      
        return area;                              
    }

    public static double areaPyramid(double length, double width ) { 
        // Calculate the base area of pyramid
        double areaTriangle = length*width;                          
        return areaTriangle;                                        
    }

    public static double volume(double area, double height) {  
        // Calculate the volume
        double volume = area * height; 
        return volume;   
    }

    public static String largestVolume(double volumeCone, double volumePyramid){
        // Evaluate if the cone's volume is larger than the pyramid's
        if(volumeCone > volumePyramid){  
            return "The cone has the largest volume";
        }
    
        // Evaluate if the cone's volume is smaller than the pyramid's  
        else if(volumeCone < volumePyramid){
            return "The pyramid has the largest volume";
        }
    
        // Else, the volumes must be the same size 
        else{ 
            return "The volumes are the same size";  
        }
    }

    public static void getInputsFromJOptionPane() {        
        // Saves the value that the user enters in a dialog box 
        // Double.parseDouble exists so that the value entered is a double              
        double radiusCone = Double.parseDouble(JOptionPane.showInputDialog(null, "Enter the radius of the cone"));   
        double heightCone = Double.parseDouble(JOptionPane.showInputDialog(null, "Enter the height of the cone"));
        double lengthPyramid = Double.parseDouble(JOptionPane.showInputDialog(null, "Enter the length of the base of the pyramid"));
        double widthPyramid = Double.parseDouble(JOptionPane.showInputDialog(null, "Enter the width of the base of the pyramid"));
        double heightPyramid = Double.parseDouble(JOptionPane.showInputDialog(null, "Enter the height of the pyramid"));
    
        // Use the areaCircle method to calculate the area. Submits the value of radiusCone.
        // The value returned from the method is saved in areaOfCone
        double areaOfCone = areaCircle(radiusCone);                       
    
        // Use the method volume to calculate the volume of the cone. Submits the value of areaOfCone and heightCone.   
        double volumeCone = volume(areaOfCone, heightCone);               
    
        // Use the areaPyramid method to calculate the area. Submits the value of lengthPyramid and widthPyramid.   
        double areaOfPyramid = areaPyramid(lengthPyramid, widthPyramid);  
    
        // Use the volume method to calculate the volume of the pyramid. Submits the value of areaOfPyramid and heightPyramid.
        double volumePyramid = volume(areaOfPyramid, heightPyramid);      
    
        // Determine volume is largest using the largestVolyme method.
        String largestVolume = largestVolume(volumeCone, volumePyramid);  
     
        // Prints the largest value in a dialog box
        JOptionPane.showMessageDialog(null, largestVolume);
    }
}

Common mistakes when calling methods in Java

Följande är några enklare misstag som vi uppmärksammat

• You don’t pay attention to the input parameters of the method. For example, what data type the method requires, what order the method uses them, etc.
• It is essential to acknowledge the data type that the method returns. If we want to save values in a different data type than what is returned from the method, we solve it with type conversion.
• Invoking non-static methods from a static context. Usually happens when trying to use the main method (which is static) to access non-static methods.

Summary: Call and use a method in Java

When you want to use a previously declared method, it’s called that you “call that method”. To call a method, enter the name of the method followed by any input parameters in parentheses. When a parameter is passed to the method, it is called an argument. Additionally, when working with multiple arguments, the method call must have the same number of arguments as there are parameters, and the arguments must be passed in the same order. Finally, if the called method returns a value, it can be assigned to a variable of the same data type.

Syntax: Use a method in Java

methodName (input parameters);

FAQ: Use methods in Java