Java Methods Explained

In this article, we will introduce you to Java Methods or functions. First of all, we will talk about what is a method, how to call a method in java, and why we use methods. After that, we will analyze the method syntax and some useful abilities.

You can also check this tutorial in the following video:

1. Introduction

A Java method is a block of code that is grouped to perform an operation. When calling a method, you can pass some data(variables or parameters)
and after processing them from the code, there will be some results that we use to continue the rest of the program.

2. Technologies used

The example code in this article was built and run using:

• Java 1.8.231(1.8.x will do fine)
• Eclipse IDE for Enterprise Java Developers- Photon

3. Java Methods Syntax

Every Java function must be in class. Java has its own pre-defined methods such as print() or sqrt() but as a programmer, you can make your own. Below you can see how is the syntax of a method:

Here is the syntax of a Java method:

Modifier ReturnType Name (Parameters)Exception{
   //code of the method
}

• Modifier: Is the access type of the method. There are 4 modifiers:
  • private: These methods can not be accessed by anywhere outside the class in which are declared.
  • public: These methods are visible to any class in the program whether these classes are in the same or another package.
  • protected: These methods can be accessed only by subclasses in other or the same package.
  • default: This modifier is used when no access modifier is present and these methods can be accessed by classes in the same package.

• ReturnType: The type of the value which the method will return.
• Name: In this place, we declare the name of the method.
• Parameter: Is the data that we pass to use them in the method. The type of them and the number can be anything.
• Exception: The exceptions you expect by the method can throw.
• Body: The body of a method is the code that defines what the method does.

3.1 How to call a method in Java

To use a function in java you have to call it. A method can return a value or return nothing so we can say that a method is called by its functionality. The call of a method in java is done when the program invokes a function. For example:

Method_call.java

import java.util.Scanner;

public class Method_call {
public static int num(int i) {
	i=i*i ;
	return i;
}
public static void main(String args[]) {
	Scanner myObj = new Scanner(System.in);
	System.out.println("Give me the a number");
	int ap = myObj.nextInt();
	int result=num(ap);
	System.out.println("The result is: "+result);
}
}

At line 12 we can see how we call a method and store the return value in a new valuable.

3.2 Void method versus return type method

Usually, we use a method to print or return any type of valuable. But how we can understand what method does what. For this reason, we need the word “void”. If a method is a “void method” then we have to print on the console a text or a variable, else, we just need to return a value after the processing of the parameters. For example:

Example_void.java

import java.util.Scanner;

public class Example_void {
	public static void first() {
		System.out.println("Do you love Java?");
	}
	public static  int second(String i) {
		if(i.equalsIgnoreCase("yes")) {
			return 1;
		}
		else if (i.equalsIgnoreCase("no")) {
			return 2;
		}
	return 0 ;	
	}
public static void main(String args[]) {
	Scanner myObj = new Scanner(System.in);
	first();
	String ap = myObj.nextLine();
	int num =second(ap);
	if(num==1) {
		System.out.println("You are the best");
	}else if(num==2) {
		System.out.println("No one is perfect");
	}else {
		System.out.println("Maybe your answer doesnt fit to my program");
	}
}
}

At highlighted code, you can see how to declare a void and a non-void method.

3.3 Static methods versus Instance Methods

Static methods are the methods that can be called without creating an object of class unlike to instance methods that require an object of its class before it can be called. But where static methods are useful? You can use static methods when you want your code to be shared across all instances of the same class. An example:

Test.java

public class Test {
public void Testone () {
	System.out.println("This is  not a static method");
}

public static void Testtwo() {
	System.out.println("This is a static method");
	
}
}

StaticVsNonStatic.java

public class StaticVsNonStatic {
public static void main(String args[]) {
	Test a=new Test();
	a.Testone();
	Test.Testtwo();
}
} 

The output is:

This is  not a static method

This is a static method

At StaticVsNonStatic.java program we can see how we call the two methods and the difference between them. You can see the non-static method uses the object “a” to call it.

3.4 Methods and exceptions

Sometimes methods can throw some exceptions, as a result, the program will not conclude and sometimes it’s difficult to find or solve a problem by yourself. So to secure your code inside of a method we can use the Exception Handling mechanism to handle the runtime errors and maintain the normal flow of the program. To handle these errors we use the Try-Catch-Finally mechanism. To understand how it works see the below example:

Throw_ex.java

import java.util.Scanner;

public class Throw_ex {
	public static int ex() throws Exception {
		Scanner myObj = new Scanner(System.in);
		System.out.println("Give me the a number between 1 and 100");
		int ap = myObj.nextInt();
		if(ap100) {
		    throw new Exception();
	        }
		return ap;
	}
	
public static void main(String args[]) throws Exception {
	try {
	int result = ex();
	System.out.println("The result is: "+result);
	}
	catch(Exception e) {
	     System.out.println("The exception handled by the caller ");
	}
}
}

The output is:

Give me the a number between 1 and 100
0
The exception handled by the caller 

As you can see at the method we throw an exception and when we call the method at main we handled it. The reason that we could handle the exception is the try-catch. At first, we call the method inside the “try” and after the exception, the “catch” handle the exception, prints a text and the program now can run normally.

4. Recursive method

Sometimes to solve problems we need to break it into smaller problems until we end up to a problem that we already know the answer. To do this we call some methods known as recursive methods. Recursive methods are methods that call themselves. To understand better these methods we did an example below:

Recursive_method.java

import java.util.Scanner;

public class Recursive_method {
	
	static int fact( int n ) {
        if (n != 0)
            return n * fact(n-1); 
        else
            return 1;
    }
public static void main(String args[]) {
	Scanner myObj = new Scanner(System.in);
	System.out.println("Give me the a number");
	int ap = myObj.nextInt();
	int result=-1;
    result = fact(ap);
    System.out.println(ap + " factorial = " + result);
}
}

The output is:

Give me the a number
10
10 factorial = 3628800

At this program, we saw how to find a factorial number. At “fact ()” method we call itself to do the calculation until the “n” becomes zero.

5. Passing by value vs passing by reference

5.1 Passing by value

Actual parameter expressions that are passed to a java function are evaluated and value is derived. Then this value is stored in a location and it becomes the formal parameter to the invoked method.

5.2 Passing by reference

The formal parameter is just an alias to the actual parameter. It refers to the actual argument. Any changes done to the formal argument will reflect an actual argument and vice versa.

To understand more about passing by reference and passing by value we will do an example.

Pass.java

public class Pass {
	String name;

	public Pass(String name) {
		this.name = name;
	}

	public String toString() {
		return name;
	}
}

Passing.java

public class Passing {
	
	public static void swap(Pass Pass1, Pass Pass2) {
		Pass temp = new Pass("");
		temp = Pass1;
		Pass1 = Pass2;
		Pass2 = temp;
	}
	
public static void main(String args[]) {
	Pass p1 = new Pass("Cat");
	Pass p2 = new Pass("Dog");

	System.out.println("Before Swap:- a1:" + p1 + "; a2:" + p2);
	swap(p1, p2);
	System.out.println("After Swap:- a1:" + p1 + "; a2:" + p2);
}
}

The output is :

Before Swap:- a1:Cat; a2:Dog
After Swap:- a1:Cat; a2:Dog

At the above program we pass two arguments and swap them inside the invoked method, then check if the actual arguments are swapped. If the actual arguments are affected then the mechanism used is pass by reference otherwise it is pass by value.

6. Method overriding

A method is an overriding method when a subclass has the same method as declared in the parent class. The overriding method is used when we want to provide the specific implementation of a method that is provided by its superclass or for runtime polymorphism. Here is an example:

Animals.java

public class Animals{
public void animal() {
	System.out.println("Here is a wild animal");
}
}

Dog.java

public class Dog extends Animals{
	public void animal(){
		System.out.println("Here is a dog");
		}  
	  
	  public static void main(String args[]){  
	  Dog an = new Dog();//creating object  
	  an.animal();//calling method  
	  }  
}
 

The output is:

Here is a dog

Here we create an object Dog. As a result, the method animal become an overriding method and the output is the print from the method of the Dog class

7. Method overloading

Overloading methods are the methods that have the same name but different signatures. With the term “signature” we mean the type of the input parameters or the number of them. The advantage of overloading is that we don’t need to create many methods with different names for the same code because of the different number or type of parameters. Here is an example

Overloading.java

public class Overloading {
	 public static void main(String args[]) {
		 Overloading s = new Overloading(); 
	        System.out.println(s.div(100, 50)); 
	        System.out.println(s.div(100, 50, 2)); 
	        System.out.println(s.div(100.5, 50.5,2.5)); 
	 }
	 public int div(int i,int j) {
			int res=i/j;
			return  res;
		}
		public int div(int i,int j,int c) {
			int res=(i/j)/c;
			return  res;
		}
		public double div(double i,double j,double c) {
			double res=(i/j)/c;
			return  res;
		}
}

The output is:

2
1
0.7960396039603961

At this code, we create 3 methods with the same name but different parameters. As we saw we didn’t have an error.

8. Varargs

Another way to save your time from the same method with different types and numbers of parameters is the varargs. Varargs or Variable Argument allows to your methods to accept zero or multiple arguments. The syntax of the varargs is:

return_type method_name(data_type... variableName){}  

Here is an example:

Varargs.java

public class Varargs {
	public static void main(String args[]){ 
		Vprint(100,"Hello world");
		Vprint(100,"Hello world","My name is ","John");
		
	}
	 static void Vprint(int i, String... str){  
		  System.out.println(i);  
		  for(String s:str){  
		   System.out.println(s);  
		  }  
	 }
}

The output is:

100
Hello world
100
Hello world
My name is 
John

So as we saw above we print all the strings that we have input because of the varargs.

9. Why we use Java methods

So the most important question is why we use methods??

The answer is that a method is used :

• For reusable code: Why write again and again the same code when you can write it once and call it every time with different parameters or use a method with the overloading mechanism which will save you time? Methods are your savior.
• To simplify your code: With methods or functions in java, you can have an order to your code and prevent accidental errors and confusion.
• To create conceptual units: Create methods to do something that is one action in your mental view of the problem.
• For top-down programming: Methods help you to solve big problems by breaking them into little pieces and solve them easier and faster.

10. Download the Source Code

In this article, we learned how to call a method in java, what is a method and why it is used.

Do you want to know how to develop your skillset to become a Java Rockstar?

Subscribe to our newsletter to start Rocking right now!

To get you started we give you our best selling eBooks for FREE!

1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design

and many more ....

I agree to the Terms and Privacy Policy

Sign up

Thank you!

We will contact you soon.