12 Java Fundamentals

Methods in Java

By Dummy for Dummies

Introduction

What if you could have an assistant in your program, one that does a specific task every time you ask? You code it once, then call it as many times as you need, and it does its job every time.

Methods

In Java, a method is a block of code enclosed in curly brackets. There is a main method always, and you can create multiple other methods if you want. Think of these like you have one boss method and many assistants.

• Boss Method → Always executes, code execution starts from here.
• Assistant Methods → You can choose to execute them multiple times, or not even once; depends on you, executes when you call them.

Let's simulate a situation: the boss monkey wants to know 2 bananas plus 3 bananas, how many total bananas? To do that math, the assistant needs the data sent to it. In programming, that data is called an Argument.

And since we store data in variables, the assistant needs a variable to catch that incoming data too. That variable is called a Parameter. So we have:

• Arguments → The data the boss monkey sends (2 bananas and 3 bananas)
• Parameters → The variables that store arguments

When we need the assistant, we will call it, tell it the data through the call, and it will receive the data. What will the assistant do with the data? We will code it to add two numbers.

public class Main {
    // Boss method - program starts here
    public static void main(String[] args) {
        System.out.println("Boss Monkey: Send data to assistant!");
        // Boss calls the assistant to calculate bananas
        assistant(2, 3);
    }

    // Assistant method → Adds two numbers (bananas)
    public static void assistant(int a, int b) {
        int total = a + b;
        System.out.println("Total Bananas: " + total);
    }
}

While creating the assistant method, you see there are a few words that need explanation. This is the assistant method:

• public → It decides who can access this assistant method. When you reach OOP and start making bigger projects, you will create many Java files. If you write "public" at the start of such a method, then from any file you can access it. If you write "private", then only from that file where it belongs. As it decides who can access this method, it is called Access Modifier.
• static → This concept is a bit more complex. Writing static means this part of code does not belong to each object you create from this, but rather all objects created from it will share this.
• void → Tells the method not to return anything. If we wanted to hand the total back instead of printing it directly, we'd write int in place of void. So void just means: does its job, returns nothing.
• assistant(int a, int b) → This is the method name. Since you can create multiple methods, each needs a name to see which one we are calling. After the name, we put brackets and inside them are parameters to receive the arguments in their respective variables. Parameters should be in the same order in which we sent the arguments.
• { } → This is where we write all that code which belongs to that specific method.

Points to Remember

• While calling a method, write its name and arguments inside it. You do not need to write the datatype of the argument when calling from the main method, i.e., just assistant(3, 2).
• When creating a specific method, for now just write public static, and decide the return type that suits you.
• The order of arguments sent and parameters must match.
• Method names should be in lower case alphabets (convention).
• The number of arguments sent and received in parameters MUST be the same.
• Methods do NOT send/receive variables; they just send/receive the data inside variables.

Methods with Specific Return Type

Let's write code that asks the user for a value, sends it as an argument, and gets a value back from the method. To return a value, write return at the end of the assistant method, followed by whatever you want to send back. That value lands right back at the exact spot in the main method where you called it.

You still need a variable to catch it though. So create the variable, write =, then call the method. The returned value gets assigned straight into that variable.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        // Asking user for a number
        System.out.print("Enter a number: ");
        int number = input.nextInt();

        // Sending the number as an argument to the assistant method
        int result = squareNumber(number);

        // Printing the returned value
        System.out.println("Square of " + number + " is: " + result);
        input.close();
    }

    // Assistant method: takes a number as parameter and returns its square
    public static int squareNumber(int n) {
        int a = n * n;
        return a;
    }
}

Exercise

Let's do an exercise for what we studied in this post. Study this code, break it down, analyze it and identify the concepts used here. It would be even better if you write down your observations and make a mini report on it.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        // Asking the user for two numbers
        System.out.print("Enter first number: ");
        int num1 = sc.nextInt();
        System.out.print("Enter second number: ");
        int num2 = sc.nextInt();

        // Calling assistant methods
        int sum = addNumbers(num1, num2);
        int product = multiplyNumbers(num1, num2);

        // Calling a void method (just prints)
        printResults(num1, num2, sum, product);
        sc.close();
    }

    // Assistant 1: adds two numbers and returns result
    public static int addNumbers(int a, int b) {
        return a + b;
    }

    // Assistant 2: multiplies two numbers and returns result
    public static int multiplyNumbers(int a, int b) {
        return a * b;
    }

    // Assistant 3: void → prints results, does not return anything
    public static void printResults(int x, int y, int sum, int product) {
        System.out.println("You entered: " + x + " and " + y);
        System.out.println("Their sum is: " + sum);
        System.out.println("Their product is: " + product);
    }
}

Mini Project: Calculator with Methods

Your project is to create a simple Java calculator using methods. The program should ask the user to enter two numbers. Show a menu of operations:

• 1 → Addition
• 2 → Subtraction
• 3 → Multiplication
• 4 → Division

The user chooses one operation. The program should call the correct assistant method to perform that operation. Print the result in a neat format using printf.

Rules:

• Use Scanner for input.
• Create at least 4 separate methods: one for addition, one for subtraction, one for multiplication, one for division.
• Use arguments, parameters, return values, and void methods.
• Handle division carefully (if the second number is 0, print "Invalid: Division by Zero").

Bonus (Optional): After showing the result, ask the user if they want to perform another calculation. If yes, repeat the process.

Example Output

Closing

That's it for methods in Java! Methods are like your program's assistants; they let you organize code into reusable, focused tasks. Once you understand how to pass data (arguments), receive it (parameters), and sometimes return results, your programs become cleaner, more powerful, and much easier to manage. You can re-use any method as much as you like. Code them once and use them multiple times.