Java Methods and Recursion Explained Simply

A method sits in the class next to main, not inside it. Its header has four parts:

1public static double grossPrice(double net)

1. public static: always goes in front for now. What it means is explained in the article on classes and objects in Java.
2. Return type: double, int, boolean, String, … or void if the method returns nothing.
3. Name: lower case, says what the method does.
4. Parameters: in parentheses, each with a type, separated by commas. When the method is called, they get the values you pass.

return hands back the result and ends the method immediately. You can store the return value, print it or keep calculating with it.

1public class Main {2    public static double grossPrice(double net) {3        return net * 1.19;4    }5
6    public static boolean isAdult(int age) {7        return age >= 18;8    }9
10    public static void printLine(int length) {11        for (int i = 0; i < length; i++) {12            System.out.print("-");13        }14        System.out.println();15    }16
17    public static void main(String[] args) {18        printLine(20);19        System.out.printf("Gross: %.2f%n", grossPrice(50.0));20        double total = grossPrice(10.0) + grossPrice(20.0);21        System.out.printf("Total: %.2f%n", total);22        System.out.println("Adult at 17? " + isAdult(17));23        printLine(20);24    }25}

Several methods may have the same name if their parameters differ, in number or type. This is called overloading. When you call it, Java picks the matching one by the arguments. One method may call another, just as max with three parameters uses the one with two.

If a method should take any number of values, put three dots after the type: int... numbers. This is called varargs. Inside the method, numbers is a normal array, an empty one if you pass nothing.

1public class Main {2    public static int max(int a, int b) {3        if (a > b) {4            return a;5        }6        return b;7    }8
9    public static int max(int a, int b, int c) {10        return max(max(a, b), c);11    }12
13    public static int sum(int... numbers) {14        int total = 0;15        for (int n : numbers) {16            total += n;17        }18        return total;19    }20
21    public static void main(String[] args) {22        System.out.println(max(3, 7));23        System.out.println(max(3, 9, 5));24        System.out.println(sum());25        System.out.println(sum(4));26        System.out.println(sum(1, 2, 3, 4));27    }28}

A method may call itself. This is called recursion and fits when a problem can be reduced to a smaller version of the same problem. Every recursion needs two parts:

• a base case that knows the result directly, e.g. factorial(1) is 1,
• a recursive call with a smaller value, e.g. n * factorial(n - 1).

This is how Java calculates factorial(3): 3 * factorial(2) → 3 * 2 * factorial(1) → 3 * 2 * 1 = 6. You'll find bigger examples in the article on recursion and backtracking.

1public class Main {2    public static void countdown(int n) {3        if (n == 0) {4            System.out.println("Go!");5            return;6        }7        System.out.println(n);8        countdown(n - 1);9    }10
11    public static int factorial(int n) {12        if (n <= 1) {13            return 1;14        }15        return n * factorial(n - 1);16    }17
18    public static void main(String[] args) {19        countdown(3);20        for (int i = 1; i <= 5; i++) {21            System.out.println(i + "! = " + factorial(i));22        }23    }24}