Methods are one of the most important building blocks in Java programming. They help organize code into smaller, reusable units, making programs easier to write, understand, and maintain. Instead of writing the same code multiple times, you can create a method once and call it whenever needed. Whether you're building a simple calculator or a large enterprise application, methods play a crucial role in creating efficient and modular Java programs.

Table of Contents

---

What is a Method in Java?

A method in Java is a block of code that performs a specific task. It is executed only when it is called from another part of the program. Methods allow developers to divide a large program into smaller, manageable sections, improving code readability and reducing duplication.
For example, instead of writing the same logic to calculate the area of a rectangle multiple times, you can create a method that performs the calculation and call it whenever required.
Syntax:

accessModifier returnType methodName(parameters) {
    // Method body
}

Explanation:

1. accessModifier: Determines where the method can be accessed from, such as public, private, or protected.
2. returnType: Specifies the type of value returned by the method. Use void if the method does not return anything.
3. methodName: The name used to call the method. It should be meaningful and follow Java naming conventions.
4. parameters: Values passed to the method when it is called. Parameters are optional.
5. method body: Contains the statements that perform the desired task.

Example:

// Java program to implement method
public class MethodExample {

    public static void greet() {
        System.out.println("Welcome to TutorialforGeeks!");
    }

    public static void main(String[] args) {
        greet();
    }
}

Output:

Welcome to TutorialforGeeks!

Explanation:

1. The method greet() is created using the void return type because it does not return any value.
2. The public keyword makes the method accessible throughout the program.
3. The static keyword allows the method to be called directly from the main() method without creating an object.
4. Inside the main() method, the statement greet(); calls the method.
5. When the method is executed, it prints "Welcome to Tutorials!" on the console.

Predefined Methods

Predefined methods, also called built-in methods, are methods that are already available in Java's standard libraries. These methods are created by Java developers and can be used directly without writing their implementation.
Some commonly used predefined methods include:

1. Math.sqrt()
2. Math.max()
3. Math.min()
4. String.length()
5. System.currentTimeMillis()

These methods save time because you do not need to implement common functionalities from scratch.

Example:

// Java program to implement predefined methods
public class PredefinedMethodExample {

    public static void main(String[] args) {

        double number = 81;

        double squareRoot = Math.sqrt(number);

        System.out.println("Square Root = " + squareRoot);
    }
}

Output:

Square Root = 9.0

Explanation:

1. A variable named number stores the value 81.
2. The predefined method Math.sqrt() calculates the square root of the given number.
3. The returned value is stored in the variable squareRoot.
4. Finally, the result is displayed using System.out.println().

Since Math.sqrt() is already implemented by Java, you only need to call it with the required argument.

User-defined Methods

A user-defined method is a method created by the programmer to perform a specific task. Unlike predefined methods, these methods are written according to the requirements of the application.
User-defined methods improve code reusability because the same logic can be called multiple times from different parts of the program.
Syntax:

returnType methodName(parameters) {
    // statements
}

Example:

// Java program to implement user-defined methods
public class UserDefinedMethodExample {

    public static void displayMessage() {
        System.out.println("Learning Java Methods is Easy!");
    }

    public static void main(String[] args) {

        displayMessage();
        displayMessage();
        displayMessage();

    }
}

Output:

Learning Java Methods is Easy!
Learning Java Methods is Easy!
Learning Java Methods is Easy!

Explanation:

1. The method displayMessage() is created by the programmer.
2. The method contains a single statement that prints a message.
3. The main() method calls displayMessage() three times.
4. Instead of writing the System.out.println() statement three separate times, the method is reused.

This makes the program shorter, easier to maintain, and less prone to errors.

Static Methods

A static method is a method that belongs to the class rather than an object of the class. Since it is associated with the class, you can call it directly using the class name without creating an object.
Static methods are commonly used for utility operations that do not depend on object-specific data. For example, methods in the Math class, such as Math.max() and Math.sqrt(), are static methods.
Syntax:

class ClassName {
    static returnType methodName(parameters) {
        // Method body
    }
}

Example:

// Java program to implement static methods
public class StaticMethodExample {

    static void displayCourse() {
        System.out.println("Course: Java Programming");
    }

    public static void main(String[] args) {

        StaticMethodExample.displayCourse();

    }
}

Output:

Course: Java Programming

Explanation:

1. The displayCourse() method is declared using the static keyword.
2. Since the method is static, it belongs to the class instead of an object.
3. Inside the main() method, the method is called using the class name:
4. StaticMethodExample.displayCourse();
5. Java executes the method and prints the course name.

Static methods are useful when the method performs a task that does not require any instance variables.

Instance Methods

An instance method is a method that belongs to an object of a class. Unlike static methods, an instance method can access both instance variables and other instance methods.
Before calling an instance method, you must first create an object of the class.
Instance methods are widely used because most real-world applications work with objects and their data.
Syntax:

class ClassName {
    returnType methodName(parameters) {
        // Method body
    }
}

Example:

// Java program to implement instance method
public class InstanceMethodExample {

    void showMessage() {
        System.out.println("Welcome to Java Programming!");
    }

    public static void main(String[] args) {

        InstanceMethodExample obj = new InstanceMethodExample();

        obj.showMessage();

    }
}

Output:

Welcome to Java Programming!

Explanation:

1. The method showMessage() is an instance method because it is not declared as static.
2. An object named obj is created using the new keyword.
3. The method is called using the object: obj.showMessage();
4. When the method executes, it displays the welcome message.

If you try to call showMessage() directly inside the main() method without creating an object, Java generates a compilation error because instance methods belong to objects, not the class itself.

Advantages of Using Methods

Methods make Java programs easier to write, understand, and maintain. Here are some of their major advantages.

1. Promotes Code Reusability: Once a method is created, it can be called multiple times without rewriting the same code. This reduces duplication and makes programs shorter and more organized. For example, a calculateSalary() method can be reused whenever salary needs to be calculated.

2. Improves Code Readability: Breaking a large program into smaller methods makes it easier to understand. Instead of reading hundreds of lines of code together, developers can focus on one method at a time. Well-named methods also make the purpose of the code clear.

3. Simplifies Program Maintenance: When a change is required, you only need to update the method instead of modifying the same logic in multiple places. This reduces the chances of introducing errors. For example, if a tax calculation changes, updating one method automatically updates every place where it is used.

4. Makes Debugging Easier: Finding and fixing bugs becomes much simpler because each method performs a specific task. You can test methods individually to identify where a problem exists. This saves time during development and troubleshooting.

5. Encourages Modular Programming: Methods divide a large application into smaller independent modules. Each module performs a specific responsibility, making the program easier to develop and manage. Modular programs are also easier to test, improve, and extend in the future.

Common Mistakes While Using Methods in Java

Even though methods are simple to use, beginners often make a few common mistakes.

1. Forgetting to Call the Method: Creating a method does not automatically execute it. The method must be called from another method, usually main().
Incorrect:

public class Demo {

    static void greet() {
        System.out.println("Hello");
    }

    public static void main(String[] args) {

    }
}

Since greet() is never called, nothing is printed.

2. Using the Wrong Return Type: The declared return type should match the value returned by the method.
Incorrect:

public static int getMessage() {
    return "Hello";
}

The method is declared to return an int but returns a String, resulting in a compilation error.

3. Calling an Instance Method Without an Object: Instance methods require an object. Trying to call them directly from a static context causes an error.
Incorrect:

public static void main(String[] args) {

    showMessage();

}

The correct approach is to create an object first.

4. Passing the Wrong Number of Arguments: The number and type of arguments passed must match the method definition.
Incorrect:

add(10);

If the method expects two parameters, passing only one argument results in a compilation error.

5. Giving Methods Meaningless Names: Method names like abc(), xyz(), or method1() make programs difficult to understand. Instead, choose names that clearly describe the method's purpose.

Conclusion

Methods are a fundamental part of Java programming because they help organize code into smaller, reusable units. By understanding different types of methods, such as predefined, user-defined, static, and instance methods, you can write programs that are cleaner, easier to maintain, and more efficient. As you continue learning Java, mastering methods will make it easier to understand advanced concepts like method overloading, recursion, and object-oriented programming.

Frequently Asked Questions

1. What is a method in Java?

A method in Java is a block of code that performs a specific task. It executes only when it is called and helps organize code into reusable and manageable sections.

2. What are the different types of methods in Java?

The commonly used types of methods in Java are:

• Predefined methods
• User-defined methods
• Static methods
• Instance methods

Each type serves a different purpose depending on the requirements of the program.

3. What is the difference between a static method and an instance method?

A static method belongs to the class and can be called without creating an object. An instance method belongs to an object, so you must create an object of the class before calling it.

4. Why are methods important in Java?

Methods improve code reusability, readability, and maintainability. They also reduce code duplication, simplify debugging, and support modular programming by breaking large programs into smaller, manageable units.

5. Can a Java program have multiple methods?

Yes. A Java program can contain multiple methods, and one method can call another method. This helps divide complex tasks into smaller, logical units, making the program easier to understand and maintain.