Home » Java Tutorial » Methods in Java

Methods in Java


Reading Time - 15 mins

What is a Method

Methods in Java or a function is a block of code that contains execution statements and operations. It mainly describes what your code can do. It is similar to the mathematical function like sqrt(square root) which finds the square root of a number. Similarly in Java, we can have functions or methods that describe a specific code behavior. We should always write methods only within a class.

Advantage of Methods in Java

  • Reusability: Methods allow us to reuse the code by just calling the specific function. This prevents us from writing redundant code and enhances reusability.
  • Readability: It makes the code more readable and understandable since we group the related actions together in a method.
  • Maintainability: Methods help us to maintain the code easier and allow us to refactor it easily when changes are required.

Types of Methods in Java

Java supports two different types of class methods:

Java methods

Standard Library Methods

These are pre-defined methods that are present in the Java library. We can use these methods without any changes. For example, we have the print() method of the System class that allows us to print a statement. We can invoke this method directly to print the statement as you can see in the below example.

public class StandardMethod {

  public static void main(String[] args) {
    System.out.println("This is a standard library method");

  }

}
This is a standard library method

User-defined Methods

When we create our own function or method, we call it a user-defined method. We can group similar actions together in a function. For example, add() is a method that adds numbers. Hence methods are used to define a task or functionality.

Next, let’s see how to create and invoke user-defined methods in Java.

Create a method

We must always create a method inside a class. A method contains a method name followed by parentheses().

READ  HashMap in Java

Below is the syntax to create a method.

access_type return_type method_name(arguments) {
//method body
}

access_type: it specifies the access modifier like public, private, protected.

return_type: Specifies if the method returns any value. It may be void(no return type) or specify a type like String or int

method_name: Any valid name that suites the method behavior

arguments: If the method requires any parameters or arguments to perform an operation. It is optional.

method body: Functionality of the method

Below is an example of creating a user-defined method. Here we have created a method add which has void return type and public access type. Inside the method body, we have a print statement.

public class MethodExample {
  
  public void add() {
    System.out.println("Addition method");
  }

}

Naming convention of a method

  • Method name always starts with a lowercase
  • It should always be a verb. Eg: add()
  • If the name contains more than two words, it should start with a verb followed by an adjective or noun. Eg: getName()
  • If there are multiple words for a method name, the first letter of the words other than the first word should start with a capital letter. Eg: getAddressDetails()

Invoke a Java method

A method is usable only when we invoke a call a method. We can call a method using the method name followed by the arguments if any within the parentheses.

method_name(arguments);

Below is a simple example of invoking a method. Since the methods are defined within a class, we can invoke the method by only using the class instance. In this example, add is the method and m is the class object.

public class MethodExample {
  
  public void add() {
    System.out.println("Addition method");
  }
  
  public static void main(String[] args) {
    MethodExample m = new MethodExample();
    m.add();
  }

}
Addition method

Method with no parameter and no return type

Below is an example of a java method that does not have any arguments or return types. When the method does not return any value, we mention the void keyword as the return type. When the method has no arguments, we mention it with empty parentheses.

We initialize the integer variables x, y using constructor, and use this value directly inside the add method. This method does not have any parameters and no return type.

public class Addition {

  int x,y;
  Addition(int x, int y) {
    this.x = x;
    this.y = y;
  }
  
  public void add() {
    int sum = x + y;
    System.out.println("Sum is: " + sum);
  }
  public static void main(String[] args) {
    Addition a = new Addition(5,8);
    a.add();
  }

}
Sum is: 13

Method with parameters but no return type

The below example illustrates a method with parameters but does not return any value. The method difference accepts two parameters both of integer type. Hence when we call the method, we need to pass the values to the method which assigns to the parameter variables inside the method. Here, x and y parameters take the values 4 and 5 respectively.

public class Subtraction {
  
  public void difference(int x, int y) {
    int diff = x - y;
    System.out.println("Difference is: " + diff);
  }

  public static void main(String[] args) {
    Subtraction s = new Subtraction();
    s.difference(10, 4);
  }

}
Difference is: 6

The main difference between class variables and parameter variables is that class variables can be used in the entire class where as parameter variables can be used only within the method.

READ  Java Continue

Method that has return type but no parameters

In the below example, the method product returns a value of integer type. Any method that has a return value should have the return statement with the value that needs to be returned. In this case, the variable product is the return value. Similarly, while invoking a method with the return type, we need to have a variable of the same type that receives the function output. Hence we use int prod = m.multiply().

public class Multiplication {

  int product,x, y;
  
  Multiplication(int x, int y) {
    this.x = x;
    this.y = y;
  }
  
  public int multiply() {
    product = x * y;
    return product;
  }
  public static void main(String[] args) {
    Multiplication m = new Multiplication(4,8);
    int prod = m.multiply();
    System.out.println("Product is: " + prod);
  }

}
Product is: 32

Method with parameter and return type

In this example, the method greaterNumber has both parameters and return value. Hence when calling the method, we should pass arguments as well as have a variable to assign the return value from the method. In this case, x and y values have 47 and 29 respectively and return the variable max from the method. While invoking the method, we have the variable value that receives the output of this method.

public class Compare {

  int max;
  
  public int greaterNumber(int x, int y) {
    if(x > y)
      max = x;
    else
      max = y;
    
    return max;
  }
  public static void main(String[] args) {
    Compare c = new Compare();
    int value = c.greaterNumber(47, 29);
    System.out.println("Greater value is: " + value);
  }

}
Greater value is: 47

Static Java Method

We have seen in the Java Static keyword tutorial, that we can use the static keyword for the methods. In this case, we do not need any class object to invoke the static method and can call using the method name directly.

public class MethodExample {
  
  public static void add() {
    System.out.println("Addition method");
  }
  
  public static void main(String[] args) {
    add();
  }

}
Addition method

Instance Methods

Methods which are non-static and that belongs to a class is called an instance method. These methods require an object or class instance to make a call to the function. This is in contrast to the static methods which do not require any object.

READ  Java Scanner

In this example, we can understand the difference in invoking an instance method and a static method. add is a static method and subtract is an instance method.

public class MethodExample {
  
  //Static method
  public static void add() {
    System.out.println("Addition method");
  }
  
  //Instance method
  public void subtract() {
    System.out.println("Subtraction method");
  }
  public static void main(String[] args) {
    MethodExample m = new MethodExample();
    
    //Invoking a static method
    add();
    
    //Invoking an instance method
    m.subtract();
  }

}

Types of instance methods

  • Accessor method: We use this method to read the instance variables. Generally, these methods have a prefix get. Accessor methods can also be called as getters to read the values of private variables.
  • Mutator method: We use this method to modify the instance variable value. They have a prefix set. These are also called as setters and are used to set the values of private variables.

These methods are used to read and update private variables from different classes.

Example:

public class InstanceMethodDemo {
  
  private String name;
  
  //Getter method
  public String getName() {
    return name;
  }
  
  //Setter method
  public void setName(String name) {
    this.name = name;
  }

  public static void main(String[] args) {
    

  }

}

Abstract method

An abstract method has only a function declaration and no definition. This means, that it does not contain a method body. We use abstract methods to implement abstraction. Abstract class contains abstract methods. The class which extends the abstract class implements the functionality of the abstract method.

abstract class class_name
{
  //abstract method
  abstract void method_name();
}

 

Reference

Array Interview Questions
Graph Interview Questions
LinkedList Interview Questions
String Interview Questions
Tree Interview Questions