Java Method Parameters: Arguments, Pass-by-Value, and Return

Parameters Let a Method Take Input

A method that always does the same thing is limited. Parameters are the inputs you declare inside the method's parentheses so the same method can work on different values each time you call it.

You list each parameter with a type and a name. Inside the method body, a parameter behaves like an ordinary local variable that already holds whatever the caller passed.

public class Main {
    static void greet(String name) {
        System.out.println("Hello, " + name + "!");
    }

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

name is the parameter. "Sam" and "Alex" are the arguments - the concrete values supplied at the call. One method definition, two different outputs.

Parameters vs Arguments

These two words get used loosely, but the distinction is worth keeping straight:

• A parameter is the placeholder in the declaration: String name.
• An argument is the value you actually pass: "Sam".

So void greet(String name) declares a parameter, and greet("Sam") passes an argument. When someone says "this method takes two parameters," they mean the declaration; "I passed two arguments" means the call.

Multiple Parameters

Separate parameters with commas, and give each one its own type - you cannot share a type across two parameters the way you might in a variable declaration:

public class Main {
    static int add(int a, int b) {
        return a + b;
    }

    static String describe(String name, int age, boolean active) {
        return name + " (" + age + ", " + (active ? "active" : "inactive") + ")";
    }

    public static void main(String[] args) {
        System.out.println(add(2, 3));
        System.out.println(describe("Sam", 30, true));
    }
}

Arguments are matched to parameters strictly by position, not by name. describe("Sam", 30, true) works because the order lines up with (String name, int age, boolean active). Swap two arguments of compatible types and you get a silent logic bug, not a compile error - so order matters.

A common mistake is writing int add(int a, b). Each parameter needs its own type: int add(int a, int b).

Returning a Value

Parameters are how data flows in; the return value is how a result flows back out. Declare the return type before the method name, and use return to hand a value back to the caller:

public class Main {
    static double average(int a, int b, int c) {
        int sum = a + b + c;
        return sum / 3.0;   // 3.0 forces floating-point division
    }

    public static void main(String[] args) {
        double result = average(4, 5, 9);
        System.out.println("Average: " + result);
    }
}

The return type (double) must match what you actually return. A method declared void returns nothing - it can still use a bare return; to exit early, but it cannot return a value. The moment return runs, the method ends and control jumps back to the call site.

Java Is Pass-by-Value

This trips up almost everyone at first. When you pass an argument, Java copies the value into the parameter. For primitives, that means the method gets its own copy - changing the parameter never touches the caller's variable:

public class Main {
    static void tryToChange(int n) {
        n = 999;   // changes only this local copy
    }

    public static void main(String[] args) {
        int x = 5;
        tryToChange(x);
        System.out.println(x);   // still 5
    }
}

x stays 5. The method modified its own copy of the number, not the original.

Passing Objects: Still by Value, but Watch the Reference

Objects feel like an exception, but they are not. What gets copied is the reference (the arrow pointing at the object), not the object itself. So the method points at the same object and can mutate it - which is exactly why adding to a shared ArrayList inside a method is visible to the caller:

import java.util.ArrayList;
import java.util.List;

public class Main {
    static void addItem(List<String> items) {
        items.add("new");        // mutates the shared object - visible to caller
    }

    static void replace(List<String> items) {
        items = new ArrayList<>();   // reassigns the local copy only - NOT visible
        items.add("ignored");
    }

    public static void main(String[] args) {
        List<String> list = new ArrayList<>(List.of("a", "b"));

        addItem(list);
        System.out.println(list);   // [a, b, new]

        replace(list);
        System.out.println(list);   // still [a, b, new] - reassignment didn't escape
    }
}

Two different outcomes, one rule. addItem follows the reference and changes the actual list, so the caller sees new appear. replace reassigns the parameter to a brand-new list - but that only repoints the local copy of the reference, so the caller's list is untouched. The takeaway: you can change an object through a parameter, but you can never make the caller's variable point somewhere new.

Next: Method Overloading

You now know how to feed a method exactly the inputs it needs. But what if you want one method name to accept different sets of parameters - say print(int) and print(String)? That is method overloading, and it is the next page.