Learn Java Basics
About Lesson

A Java Method, also known as a Method in Java, is comprised of a set of statements designed to carry out a particular task and provide the caller with a result. It is possible for a Java method to complete a specific task without returning any value. The usage of methods in Java enables the reuse of code without the need for re-typing. It is important to note that every method in Java must belong to a class, which distinguishes it from languages such as C, C++, and Python.

Method Signature

The method signature in Java is a combination of its name and the types of its parameters. It uniquely identifies a method and distinguishes it from other methods with the same name but different parameters. The signature of a method does not include its return type or the access modifiers.

For example, consider the following method signature:

public int addNumbers(int num1, int num2)

Here, the method name is “addNumbers”, and it accepts two integer parameters “num1” and “num2”. The return type of this method is “int”, and the access modifier is “public”. Therefore, the method signature is:

addNumbers(int, int)

If there were another method with the same name, but different parameters, such as:

public int addNumbers(int num1, int num2, int num3)

Then, the signature of this method would be:

addNumbers(int, int, int)

Note that the method signature is not the same as the method implementation or the method body. It only describes the method’s name and the types of its parameters.

Ways of Method

A method can be defined in several ways, including:

  1. Method Signature: The signature of a method is a combination of its name and the types of its parameters. A method signature uniquely identifies a method and distinguishes it from other methods with the same name but different parameters.

  2. Access Modifiers: Java provides four access modifiers that define the scope of a method. These are public, private, protected, and default. The access modifier determines whether a method can be accessed from other classes and packages.

  3. Method Overloading: In Java, it is possible to define multiple methods with the same name but different parameters. This is known as method overloading. The compiler determines which method to call based on the number and types of arguments passed.

  4. Method Return Type: Every Java method has a return type, which specifies the type of value returned by the method. If a method does not return a value, its return type is void.

  5. Method Parameters: Java methods can accept zero or more parameters, which are used to pass values to the method. Parameters are defined in the method signature and are separated by commas.

  6. Method Body: The method body contains the set of statements that are executed when the method is called. The method body is enclosed in curly braces and can include any number of statements.

How to Name a Method?

Naming a method in Java is an important aspect of writing clean and maintainable code. A good method name should be descriptive and indicate the purpose of the method. Here are some guidelines to follow when naming a method:

  1. Use descriptive names: A method name should clearly indicate what the method does. Use verbs to describe the action that the method performs. For example, “calculateInterest”, “sortArray”, “displayMessage”, etc.

  2. Use camelCase: In Java, method names typically start with a lowercase letter and use camelCase to separate words. For example, “calculateInterest”, “sortArray”, “displayMessage”, etc.

  3. Be concise: Avoid using long method names that are difficult to read and understand. Keep the method name short and to the point.

  4. Use meaningful names for parameters: If a method takes parameters, use meaningful names to describe what the parameters represent. For example, “calculateInterest(double principal, double rate, int time)”.

  5. Use common naming conventions: Java has common naming conventions for methods such as getter and setter methods. For example, a getter method for a variable named “name” would be named “getName”, and a setter method would be named “setName”.

  6. Avoid using abbreviations: Try to avoid using abbreviations in method names, as they can make the code harder to read and understand. Instead, use full words that describe what the method does.

  7. Use consistent naming: Use consistent naming throughout your codebase. This makes it easier to understand and maintain the code.

Method Calling

Method calling is the process of invoking a method in Java. A method can be called by using its name followed by parentheses “()”. The parentheses may contain arguments if the method takes any parameters. Here is an example of calling a method:

public class MyClass {
public static void main(String[] args) {
int result = sum(5, 10); // calling the method sum with arguments 5 and 10
System.out.println("The result is: " + result);

public static int sum(int num1, int num2) {
return num1 + num2; // method body that adds num1 and num2 and returns the result

In this example, the method sum takes two integer parameters num1 and num2 and returns their sum. The main method calls the sum method by passing two arguments 5 and 10 and stores the returned value in the result variable. The println method is then called to print the result to the console.

Note that in order to call a method, it must be accessible from the calling method. If the method is defined in a different class, the class containing the calling method must have access to that method either through inheritance or by creating an instance of the class.

Memory Allocation for Methods Calls

When a method is called in Java, memory is allocated on the stack for the method parameters and local variables. The stack is a region of memory used for temporary storage of data during method calls and is organized as a Last-In-First-Out (LIFO) data structure.

When a method is called, a new stack frame is created on the stack to hold the method’s parameters, local variables, and return address. The return address is the memory address of the instruction to resume execution after the method call completes.

As the method executes, its parameters and local variables are pushed onto the stack. When the method returns, the stack frame is popped off the stack, and the return value is pushed onto the stack to be used by the calling method.

In Java, method calls can be nested, meaning that one method can call another method, which can in turn call another method, and so on. Each method call creates a new stack frame, and the stack grows in size with each new method call. When a method returns, its stack frame is removed, and the stack shrinks in size.

It’s important to note that in Java, objects and arrays are allocated on the heap, not the stack. When a method is called and an object is passed as a parameter, a reference to the object is pushed onto the stack, not the object itself. The object itself remains on the heap until it is no longer referenced and can be garbage collected.

Advantages and Disadvantages of methods

Advantages of Methods Disadvantages of Methods
Modularity: Methods allow code to be organized into smaller, more manageable units. This makes code easier to read, write, and maintain. Overhead: There is some overhead involved in calling methods, which can affect performance in performance-critical applications.
Code Reusability: Methods can be reused in different parts of a program, which reduces code duplication and promotes code reuse. Abstraction: Overuse of methods can lead to abstraction, making the code harder to understand and debug.
Encapsulation: Methods provide a way to hide implementation details and limit the scope of variables, which improves code quality and security. Complexity: Overuse of methods can lead to code complexity, making it harder to understand and debug.
Ease of Testing: Methods are self-contained units that can be easily tested and debugged in isolation, which simplifies the testing process. Limited Access to Variables: Methods can only access variables that are passed in as parameters or declared within the method, which can limit the scope of the method.
Ease of Maintenance: Methods can be modified or replaced without affecting other parts of the program, which simplifies maintenance and reduces the risk of introducing bugs. Dependencies: Overuse of methods can create unnecessary dependencies between different parts of a program, which can make the code harder to maintain.
Join the conversation