Methods

A method is a named piece of work. You have already called println and length; now you will define your own operations. Defining a method does not run its body. A call, with parentheses after the name, tells Java to execute that method. When it finishes, execution returns to the statement after the call.

In today’s classic Main program, helper methods use static so main can call them directly. A static method belongs to the class rather than to one object. We will contrast instance methods on Day 5. void means the method does not return a value to its caller. It may still print or perform other work.

Keep definitions beside main

Methods are declared inside the class, alongside main, not inside main’s body. A closing brace ends each method, and the final brace ends the class. Blank lines between methods make these boundaries easier to read. Indentation is for people; the braces determine the structure Java compiles.

Choose a name describing the work: printHeader is clearer than doStuff. Extract a method when it represents a meaningful operation, not simply because there are two lines. A method called from several places makes one change apply to every call, reducing the chance that copied versions drift apart.

public class Main {
    public static void main(String[] args) {
        printHeader();
        System.out.println("Java");
        printHeader();
    }

    static void printHeader() {
        System.out.println("Study plan");
        System.out.println("----------");
    }
}

Study plan
----------
Java
Study plan
----------

Java enters main first, even though the helper is written below it. Each call runs the same body. Remove both calls: the definition remains valid, but its output disappears.

public class Main {
    public static void main(String[] args) {
        System.out.println("Before");
        printGoal();
        System.out.println("After");
    }

    static void printGoal() {
        System.out.println("Practise every day");
    }
}

Before
Practise every day
After

The helper finishes before main proceeds. Draw an arrow from the call to the helper, then another back to the next statement. Definitions can be below the place where they are called.

public class Main {
    public static void main(String[] args) {
        printGoall();
    }

    static void printGoal() {
        System.out.println("Practise");
    }
}

Your turn

public class Main {
    public static void main(String[] args) {
        // Call your helper around the message.
    }

    // Define the helper alongside main.
}

public class Main {
    public static void main(String[] args) {
        printSeparator();
        System.out.println("Java practice");
        printSeparator();
    }

    static void printSeparator() {
        System.out.println("===");
    }
}

===
Java practice
===

Change it and explain

Change the separator from === to --- in just one place. Then call the helper inside a loop that runs three times and predict how many lines it prints. A loop repeats a call; a method definition alone does not repeat or execute.

Read the braces aloud: class starts, main starts, main ends, helper starts, helper ends, class ends. If a compiler reports an illegal start near your helper, check whether you accidentally placed its declaration inside main. Repair the structure before trying to repair unrelated lines further down.