Java Methods

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

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

• Methods are written inside the class, but outside other methods.
• static means the method belongs to the class itself, so main can call it directly. You'll meet non-static methods in the classes lesson.
• void means the method doesn't return anything.
• Call a method by writing its name followed by brackets: greet();

Parameters are variables listed in the method's brackets, each with its type:

static void greet(String name, int times) {
    for (int i = 0; i < times; i++) {
        System.out.println("Hi " + name);
    }
}

When you call it, pass arguments of the right types, in the right order: greet("Zoe", 2);. Passing greet(2, "Zoe") won't compile, which is exactly the kind of mistake Java's types catch for you.

Replace void with a type when the method gives back a value, and use return to send it:

static int square(int n) {
    return n * n;
}

int result = square(7);   // 49

• The returned value must match the declared return type.
• return ends the method immediately.
• A method can return any type: int, double, boolean, String, arrays or your own classes.

Java allows several methods with the same name as long as their parameter lists differ in number or types. This is called overloading:

static int add(int a, int b) { return a + b; }
static double add(double a, double b) { return a + b; }
static int add(int a, int b, int c) { return a + b + c; }

Java picks the right version from the arguments you pass. println is overloaded too, which is why it can print numbers, text and booleans.

Java always passes arguments by value: the method receives a copy of each value. For primitives such as int, that means a method can't change the caller's variable:

static void addOne(int n) {
    n = n + 1;          // changes the copy only
}

After int x = 5; addOne(x);, x is still 5. To get a new value out of a method, return it: x = plusOne(x);.

For objects and arrays, the value that gets copied is the reference, the arrow pointing to the object. Both the caller and the method then point at the same object, so a method can change the object's contents, for example by appending to a StringBuilder or changing an array element. But assigning a brand-new object to the parameter only changes the method's copy of the arrow; the caller still sees the original object.

Sometimes a method should accept any number of values. Add ... after the parameter type to make a varargs parameter, which arrives inside the method as an array:

static int sum(int... numbers) {
    int total = 0;
    for (int n : numbers) {
        total += n;
    }
    return total;
}

Now sum(), sum(4) and sum(1, 2, 3) all work, returning 0, 4 and 6. A varargs parameter must be the last one in the list, and a method can have only one. String.format and List.of use varargs, which is why they accept as many values as you like. The companion lessons on parameters and return values and overloading go further.