Java Methods and Program Decomposition

A method is a named block of statements that performs a task. Defining a method makes that task available; calling it makes the task run.

Read the header and body

public static void printLine() {
    System.out.println("----------");
}

The first line is the header. Read its parts from left to right:

• public allows code in other classes to call the method.
• static makes the method belong to the class. No object is needed to call it.
• void says the method returns no value.
• printLine names the task.
• () is the empty parameter list: this method needs no input.

The braces enclose the body, the statements that run on a call. There is no semicolon between this header and its opening brace.

Put the definition in the class

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

    public static void printLine() {
        System.out.println("----------");
    }
}

main and printLine are separate methods inside Main. The closing brace of main comes before the definition of printLine. A method cannot be defined inside another method; a misplaced brace can produce "illegal start of expression".

Definitions may appear in either order. Moving printLine above main does not change when it runs. A method that is never called does not run just because its definition appears in the file.

Follow a call and the return to the caller

The call printLine(); consists of the name, parentheses, and a semicolon because the call is a statement on its own. Execution starts in main:

1. Print "Start".
2. Enter printLine, print ten dashes, then continue after the call.
3. Print "Middle".
4. Enter printLine again and print ten dashes again.

The output is:

Start
----------
Middle
----------

Both calls use the same definition. Changing its printed line changes both places that use it.

Name and call methods accurately

Use a verb or verb phrase in camelCase, starting with a lowercase letter: printReceipt, calculateAverage, or isValidCode. Java treats uppercase and lowercase as different: PrintLine() cannot find a method named printLine. Writing printLine; also fails; the parentheses are part of the call.

For a static method in another class, write the class name first. Math.max(3, 8) gives 8, Math.abs(-4) gives 4, and Math.sqrt(16.0) gives 4.0. Your own methods in the same class can be called by name alone.

These examples use the classic class-based form with public static void main(String[] args). Java 25 also supports compact source files with void main() and no surrounding class. Keep the classic form when running these examples; its helper methods are declared static. Methods such as System.out.println that you call from Java's library need not themselves be static.

A parameter lets one method handle values that change from call to call. An argument is the value supplied for that parameter when the method is called.

Give each input a type and a name

public static void printStars(int count) {
    for (int i = 0; i < count; i++) {
        System.out.print("*");
    }
    System.out.println();
}

int count declares one parameter. In printStars(3);, the argument 3 becomes the starting value of count. The loop runs three times, so it prints ***, then println() ends the line. printStars(8); uses the same body with count equal to 8.

The type is written in the definition, not in the call. Write printStars(5);, not printStars(int 5);.

Evaluate arguments before entering the body

An argument can be a literal, a variable, or an expression:

int n = 4;
printStars(n * 2);

Java evaluates n * 2 first. It passes the resulting value 8, so the body starts with count equal to 8. The caller's variable name does not have to match the parameter's name.

Match several parameters by position

Each parameter needs its own type. A rectangle method can start with this header:

public static void printRectangle(int width, int height)

The call printRectangle(5, 2); gives width the value 5 and height the value 2. Reversing the arguments gives a rectangle 2 wide and 5 high. Both calls compile because both arguments are ints; only the intended shape tells you which order is right. Writing (int width, height) in the header fails because height has no declared type.

Different types make some ordering mistakes easier to catch:

public static void printRepeated(String text, int times) {
    for (int i = 0; i < times; i++) {
        System.out.print(text);
    }
    System.out.println();
}

printRepeated("ab", 3); prints "ababab". printRepeated(3, "ab"); cannot match a String followed by an int. The number of arguments must also match: printRectangle(5); leaves one parameter without a value.

Check compatible numeric types

Java automatically widens an int to a double. A method with parameters (double km, double hours) accepts the arguments (150, 2), giving it 150.0 and 2.0. Every int value can be represented exactly as a double.

Java does not implicitly narrow a double argument to an int parameter. printStars(2.9); fails because converting it would lose the fractional part. The explicit cast in printStars((int) 2.9); produces 2, so two stars are printed. Use a cast only when dropping that part is the intended behavior.

Choose a parameter for each piece of information the task needs. Receiving text and a count makes printRepeated usable from keyboard input, a fixed test call, or another method. Its body does not have to decide where those values came from.

A return value is a result sent from a method to its caller. Once a call finishes, the call can be used as an expression with that result's type.

Declare what comes back

public static int sum(int a, int b) {
    return a + b;
}

int replaces void in the header because this method gives back an integer. The return statement evaluates a + b and sends the value to the call site. For sum(4, 7), that value is 11.

The caller decides what happens next:

int total = sum(4, 7);
System.out.println(sum(4, 7));
int doubled = sum(2, 3) * 2;

The first line stores 11; the second prints 11; the third stores 10. A returned value can also be used in a condition, such as if (sum(a, b) > 10).

A compatible int result may widen when returned from a double method. A double result cannot be returned from an int method without a suitable explicit conversion.

Calculate the expression before converting the result

public static double average(int a, int b) {
    return (a + b) / 2.0;
}

For average(3, 4), the numerator is 7. Dividing by the double literal 2.0 gives 3.5. If the expression were (a + b) / 2, Java would first divide two ints and get 3. Only then would it widen that value to the returned 3.0. A double return type does not repair integer division already performed inside the body.

Separate returning from printing

A void call cannot fill a value in an assignment or another call. If printSum is void, int total = printSum(1, 2); fails even though printSum prints a number. Use a value-returning method for calculations and let the caller choose whether to print.

Return text and yes-or-no results

Return types also include String and boolean. A greeting method can return "Hello, " + name + "!", giving "Hello, Ana!" for the argument "Ana". An isEven(int n) method can return n % 2 == 0.

A formatter turns a number into reusable text:

public static String formatDuration(int minutes) {
    return minutes / 60 + " h " + minutes % 60 + " min";
}

For 135, integer division gives 2 whole hours and the remainder gives 15 minutes. The result is "2 h 15 min"; for 60, it is "1 h 0 min".

Keep or combine the result

A call such as sum(4, 7); compiles, but discards its result. If square(x) returns a new value, use x = square(x); to store it in x.

A result can also become an argument immediately. In Math.max(sum(1, 2), 4), sum(1, 2) first gives 3, then Math.max(3, 4) gives 4. Evaluate the inner call before using its result in the outer one.

A return statement ends the current method call immediately. Inside a condition or a loop, it still leaves the whole method, not just that block.

Give each route an answer

public static int larger(int a, int b) {
    if (a > b) {
        return a;
    }
    return b;
}

larger(9, 4) returns 9 from inside the if. For larger(2, 6), the if body is skipped and the final return gives 6. Equal inputs such as (5, 5) also reach the final return, giving 5. No else is needed after the first return because that route has already left the method.

In an ordinary value-returning method, no possible route may reach the closing brace without supplying a value. A sign method that returns only for positive and negative inputs leaves zero without an answer:

public static String sign(int n) {
    if (n > 0) {
        return "positive";
    } else if (n < 0) {
        return "negative";
    }
    return "zero";
}

The final return completes the method. Two separate if statements, one testing n > 0 and one testing n <= 0, still need a final return or a clear if/else structure. Java's return check does not infer that those two comparisons cover all integers. A statement directly after an unconditional return in the same block is unreachable and is rejected.

Finish a search at the right moment

public static int firstMultipleOf7(int start, int end) {
    for (int i = start; i <= end; i++) {
        if (i % 7 == 0) {
            return i;
        }
    }
    return -1;
}

For (10, 20), the loop rejects 10, 11, 12, and 13, then returns 14. The call ends without checking 15 through 20. For (15, 20), the loop finishes without a match, so the return after it gives -1, the agreed "not found" signal.

Putting else { return -1; } inside the loop would quit after the first failed candidate. The search from 10 would then report failure before reaching 14. Failure belongs after all candidates have been tried.

Return the condition itself

A comparison already produces a boolean. Write return n % 2 == 0; instead of an if/else that returns true and false separately. A boolean method's name often starts with is or has, so a call reads naturally inside an if.

public static boolean isLeapYear(int year) {
    return (year % 4 == 0 && year % 100 != 0)
        || year % 400 == 0;
}

This returns true for 2024 and 2000, but false for 1900 and 2023. Use if (isLeapYear(y)) directly.

Leave a void method early

A void method uses return; without a value. For example, printSquareRoot(double x) can print "No real square root" and return immediately for a negative input. For other inputs it can print Math.sqrt(x), which gives 1.5 for 2.25. Writing return 5; in a void method fails because its header promises no returned value.

A variable's scope is the region of code where its name can be used. Start with the braces around its declaration: a local name belongs to a particular method or block.

A caller's locals stay in the caller

public static void main(String[] args) {
    int price = 20;
    printDouble(price);
}

public static void printDouble(int price) {
    System.out.println(price * 2);
}

The price in main and the parameter price in printDouble are separate variables. The argument supplies the value that the helper needs, so the helper prints 40.

Removing the parameter and calling printDouble() does not let the helper read main's local price. Its body would fail with "cannot find symbol". Calling one method from another does not join their scopes. Different methods may each use the name count without linking their variables.

A nested block makes a smaller scope

A local variable can be used from its declaration through the closing brace of its block. A parameter is available throughout its method body. A counter declared in for (int i = 0; i < 3; i++) belongs to that loop; i cannot be read afterward.

To keep a result after a loop, declare it before the loop:

int sum = 0;
for (int i = 1; i <= 5; i++) {
    sum += i;
}
System.out.println(sum);

The additions take sum through 1, 3, 6, 10, and 15. The final print can read sum because the surrounding block has not ended. i is needed only for the loop and stays inside its scope.

Moving int sum = 0; into the loop body creates a new sum on every pass. Each one starts at zero and disappears at the end of that pass. It cannot hold a running total or be printed after the loop.

Check names and starting values separately

Two locals with the same name cannot have overlapping scopes inside one method. A method with a parameter x cannot declare another local x; a loop that declares i cannot declare another i in its body. Rename the second variable or use the existing one.

Two loops one after the other may each declare int i. The first loop's scope has ended before the second declaration. Braces, not the whole file, determine that reuse.

A legal name also needs a value before it is read. int total; total++; fails because ++ must read the old value, and a local variable gets no automatic starting value. Use int total = 0; for a running total.

Keep a local variable in the smallest block that needs it. If a method needs information from its caller, make that information a parameter. If the caller needs a result, return it. Then the method's header and body show where its data comes from.

Java passes arguments by value. At the start of a call, each parameter receives a copy of its argument's value. Assigning to the parameter changes that local variable.

Trace the copy separately

public static void main(String[] args) {
    int score = 10;
    addBonus(score);
    System.out.println(score);
}

public static void addBonus(int score) {
    score = score + 5;
    System.out.println(score);
}

There are two variables called score. Trace their values at each point:

The helper prints 15, then main prints 10. Sharing a name does not make the two variables share storage. Renaming the parameter would not change this behavior.

Return the new value and store it

public static int addBonus(int score) {
    return score + 5;
}

With this version, write score = addBonus(score);. Java copies the old value into the parameter, computes 15, returns it, and assigns it to the caller's variable. The assignment in the caller is the step that changes that variable.

A result can also be stored elsewhere. If triple(int n) multiplies its local n by 3 and returns it, then int a = 4; int b = triple(a); leaves a equal to 4 and gives b the value 12. Printing a + " " + b displays "4 12".

Apply the same rule to String references

A String variable holds a reference to a String object. Java copies that reference into a String parameter:

public static void exclaim(String text) {
    text = text + "!";
}

If the caller's word refers to "hi", exclaim(word); leaves word referring to "hi". Concatenation creates a new String, and the assignment changes only what the parameter refers to. Strings cannot have their existing contents changed.

To keep the new text, return text + "!" from a String method such as exclaimed, then write word = exclaimed(word);.

For mutable objects, such as lists, a copied reference can still point to the same object. A method can change that object's contents through the copied reference. Reassigning the parameter still cannot make the caller's variable refer to a different object. The copied-reference rule and the copied-number rule are both pass by value.

You may reassign a parameter, but a separate local such as result can make a longer calculation easier to read: it keeps the original input available while showing which value will be returned.

The call stack records calls that have started but have not yet finished. Each call gets a stack frame with its parameters, local variables, and the place where its caller will continue.

Push a frame, finish it, then pop it

The stack works last in, first out. The newest call is on top and runs while its caller waits below it. When it returns, Java removes its frame and resumes the caller.

public static void main(String[] args) {
    int total = totalSeconds(2, 30);
    System.out.println(total);
}

public static int totalSeconds(int minutes, int seconds) {
    int fromMinutes = toSeconds(minutes);
    return fromMinutes + seconds;
}

public static int toSeconds(int minutes) {
    return minutes * 60;
}

Follow the unfinished work:

1. main starts and calls totalSeconds(2, 30). Its assignment to total must wait.
2. The new frame has minutes = 2 and seconds = 30. It calls toSeconds(minutes) and waits for fromMinutes.
3. toSeconds gets its own minutes = 2. It returns 120 and its frame is popped.
4. totalSeconds stores fromMinutes = 120, adds 30, and returns 150. Its frame is popped.
5. main stores total = 150 and prints 150.

At the deepest point, the frames from bottom to top are main, totalSeconds, and toSeconds. Both helpers have a parameter named minutes, but those parameters occupy different frames. The waiting caller's locals do not become visible to the method above it.

A later call gets a fresh frame. A local counter does not remember its previous value after its call has ended; the return value is what can carry a result back.

Read a stack trace from the error outward

An unhandled exception prints a stack trace that shows where the error happened and which calls led there. Here is a complete file:

public class Main {
    public static void main(String[] args) {
        report(300, 0);
    }

    public static void report(int meters, int minutes) {
        int speed = perMinute(meters, minutes);
        System.out.println(speed + " m per minute");
    }

    public static int perMinute(int meters, int minutes) {
        return meters / minutes;
    }
}

The first output line is Exception in thread "main" java.lang.ArithmeticException: / by zero. The frames beneath it are:

at Main.perMinute(Main.java:12)
at Main.report(Main.java:7)
at Main.main(Main.java:3)

The top frame identifies the integer division by zero. The next two locate the calls that supplied the path to it. The line numbers belong to this exact file layout; adding a line changes them.

The stack has finite space. A chain that keeps adding calls without letting them finish can cause StackOverflowError. A debugger's stack view lets you inspect the same chain while paused at a breakpoint, including each waiting call's separate variables.

Overloading gives methods the same name with different parameter lists. It is useful when the methods perform the same job for different numbers or types of input.

Compare signatures

For these methods, a signature consists of the name and the ordered parameter types. The number of parameters follows from that list.

public static int max(int a, int b) {
    if (a > b) {
        return a;
    }
    return b;
}

public static int max(int a, int b, int c) {
    return max(max(a, b), c);
}

public static double max(double a, double b) {
    if (a > b) {
        return a;
    }
    return b;
}

The signatures are max(int, int), max(int, int, int), and max(double, double). max(3, 9) returns 9 using the first. max(3, 9, 5) calls the second: the inner two-int call returns 9, then the outer two-int call compares 9 and 5, also returning 9. max(2.5, 1.0) uses the double version and returns 2.5.

Know which changes do not count

Changing only a return type does not create an overload. These headers conflict:

public static int area(int w, int h)
public static double area(int w, int h)

Both have the signature area(int, int). Java rejects the duplicate declaration. Renaming the parameters to width and height leaves the same signature too: callers supply values by position, not by parameter name.

The order of different types does count. describe(String s, int n) and describe(int n, String s) are distinct signatures. They compile together, but a caller has to remember an easy-to-confuse ordering, so use such a pair only when it helps the design.

Let a shorter overload supply a default

Java does not provide default parameter values in method declarations. A shorter overload can call a longer one with a fixed argument:

public static void printLine(int length, char symbol) {
    for (int i = 0; i < length; i++) {
        System.out.print(symbol);
    }
    System.out.println();
}

public static void printLine(int length) {
    printLine(length, '-');
}

printLine(5, '*'); prints *****. printLine(4); enters the shorter method, which calls the longer one with 4 and '-', printing ----. The loop lives in one place, so changes to the printing task apply to both forms.

Java's library also uses overloads. System.out.println accepts an int, a double, a char, a boolean, or a String through different versions. Math.abs and Math.max offer versions for int, long, float, and double.

Keep one meaning for the shared name. Printing a receipt and printing a label are different jobs; clear names such as printReceipt and printLabel tell the caller which job will happen.

The compiler chooses an overload from the argument count and argument types. Work out that choice before considering how the returned value will be used.

Start with exact matches

Suppose a class defines show(int x) and show(double x). show(5) uses the int version because the literal 5 is an int. show(5.0) uses the double version. A whole-number value written as 5.0 is still a double expression.

For a call with several arguments, compare the type in every position. A candidate with the wrong argument count cannot fit.

Allow widening when needed

If only show(double x) exists, show(5) is valid: the int widens to 5.0. The primitive widening paths include:

byte → short → int → long → float → double
char → int → long → float → double

With both show(long x) and show(double x), an int argument chooses long. That is the more specific compatible parameter type: a long can widen to double, while a double cannot widen back to long.

Widening means a permitted numeric conversion; it does not promise that every such conversion preserves every digit. In particular, converting a sufficiently large long to double can round its value. The int-to-double conversion used in the earlier examples preserves all int values exactly.

A char also has a numeric value. With letter(int code) and letter(String text), letter('A') calls the int version with 65. A character does not become a String to match a parameter. Double quotes in "A" would instead make a String argument.

Reject implicit narrowing

With only show(int x), show(5.0) fails. Java does not narrow a double argument just because its value happens to be a whole number. show((int) 5.0) passes an int after an explicit cast.

Likewise, versions of max for two and three ints cannot accept max(1). No candidate has the required number of parameters, so the compiler reports "no suitable method found". Compare the candidate list with the supplied arguments.

Keep overload selection separate from result conversion

Consider int twice(int n) and double twice(double x). In double d = twice(3);, the argument selects the int overload. That call returns 6, then the assignment widens it to 6.0. The destination d does not select the double overload.

Recognize an ambiguous call

public static void combine(int a, double b) { }
public static void combine(double a, int b) { }

combine(1, 2) fits the first after widening its second argument and the second after widening its first. Neither signature is more specific across both positions. Java reports "reference to combine is ambiguous"; it does not choose the definition written first.

combine(1, 2.0) fits only (int, double), because the other signature would need a narrowing conversion of 2.0. A clear argument type or a better set of overloads removes the ambiguity.

Decomposition means dividing a problem into smaller tasks and solving each task in its own method. Choose tasks whose names help someone read the program's plan.

Separate calculation from input and output

A bike-ride program needs a speed calculation and a report. They use the same data but have different jobs:

public static double kilometersPerHour(double km, double hours) {
    return km / hours;
}

public static void printRideReport(double speed) {
    System.out.println("Speed: " + speed + " km/h");
}

For a ride of 150 km in 2 hours, the calculation returns 75.0. The reporting method receives that value and displays it. A caller connects the steps:

double speed = kilometersPerHour(150, 2);
printRideReport(speed);

The calculation reads no keyboard input and prints no report. Another program can use it to compare rides or store speeds without changing its body. To test it, call it with known inputs and compare the returned number with the expected one.

Recognize a method with too many jobs

A name such as readAndCheckAndPrint suggests several actions. Other clues include sections marked by comments, a body longer than one screen, and groups of variables that serve unrelated purposes. These are reasons to inspect the method, not mechanical limits on how many lines it may have.

Split at a meaningful boundary. Input code can obtain a value, a boolean helper can check it, a calculation can return a result, and a reporting method can display it. Then main reads like a short account of how those tasks connect.

Focused methods are easier to read on their own, reuse, and test. If a reporting format changes, edit the reporting method. If a calculation is wrong, test that calculation without needing to type a whole session of input.

Let the header explain the data flow

In kilometersPerHour(double km, double hours), the name states the result, the parameter names state the quantities, and the double return type states the kind of answer. A short Javadoc comment can add the meaning of the inputs and result:

/**
 * Calculates a ride's average speed.
 * @param km distance in kilometers
 * @param hours elapsed time in hours, greater than zero
 * @return speed in kilometers per hour
 */

Place that comment directly above the method header. A useful comment adds information such as units or an input requirement; it need not narrate each line of the body.

A helper needed only by its own class can be private static. private prevents other classes from calling it, while code in the same class can still use it. public static makes the helper available to other classes.

Splitting every obvious statement into its own wrapper can also obscure the plan. Keep a method when its name stands for a meaningful step or reusable calculation. A chain of helpers that merely pass the same call along adds more places to inspect without explaining more of the task.

Duplicate code repeats the same job in more than one place. When only the input values differ, one parameterized method can keep the shared work together.

Find the shared calculation

Suppose a program sums from 1 to 10, then from 1 to 50:

int total1 = 0;
for (int i = 1; i <= 10; i++) {
    total1 += i;
}
System.out.println("Sum 1 to 10: " + total1);
int total2 = 0;
for (int i = 1; i <= 50; i++) {
    total2 += i;
}
System.out.println("Sum 1 to 50: " + total2);

Both loops start at 1, add into a total, and stop at an upper limit. Only that limit changes. A parameter n can carry it into a shared calculation.

Extract the method

public static int sumUpTo(int n) {
    int total = 0;
    for (int i = 1; i <= n; i++) {
        total += i;
    }
    return total;
}

n is the varying input. total and i are working variables that belong inside the helper. The caller needs the finished sum, so the helper returns an int.

Replace both repeated sections:

System.out.println("Sum 1 to 10: " + sumUpTo(10));
System.out.println("Sum 1 to 50: " + sumUpTo(50));

sumUpTo(10) returns 55, and sumUpTo(50) returns 1275. The printed lines are "Sum 1 to 10: 55" and "Sum 1 to 50: 1275", as before. The descriptions remain in the caller; the loop performs only the calculation.

Check the extraction in a fixed order

1. Mark the statements doing the repeated job.
2. Identify every value that differs between the copies.
3. Make those values parameters with suitable types, and return any result needed outside.
4. Replace every copy with a call using its original inputs.
5. Run the same inputs before and after, and compare the behavior.

Changing code's structure while preserving its behavior is refactoring. Leaving one original copy behind means a later fix still has two places to update. Moving a print into a loop or changing a loop endpoint is a behavior change, even when the code is now shorter.

When two differences have different types, use matching parameters. Repeating different text different numbers of times suggests printRepeated(String text, int times); the word is a String and the count is an int.

Similar-looking code does not always do the same job. A boolean parameter that switches a method between unrelated calculations can make its calls hard to interpret. Give distinct jobs distinct names. Extract the repeated operation only when varying its inputs preserves one clear meaning.

Top-down design starts with the whole task and refines it into smaller method calls. Decide what each call needs and returns before filling in every detail.

Plan the steps and headers

A weekly exercise program reads 7 daily durations, totals them, and prints a report. Its helpers can be planned as:

• readMinutes(Scanner scanner, int day) returns one valid day's minutes.
• isValidMinutes(int minutes) answers whether the input is from 0 to 1440.
• formatDuration(int minutes) returns text with whole hours and remaining minutes.
• averagePerDay(int total, int days) returns a double average.
• printSummary(int totalMinutes, int days) prints the report.

The same Scanner is passed to every input call. A helper such as isValidMinutes has no need to read input itself.

Use stubs while building

A stub has its final header but a temporary minimal body, such as return 0;. It lets the program compile before a helper is implemented. Replace one stub, compile, and check that method before replacing the next. A compiling stub is still unfinished work; its fixed answer cannot verify a real calculation.

Here is the completed program:

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int total = 0;
        for (int day = 1; day <= 7; day++) {
            total += readMinutes(scanner, day);
        }
        printSummary(total, 7);
    }

    public static int readMinutes(Scanner scanner, int day) {
        System.out.println("Minutes for day " + day + ":");
        int minutes = scanner.nextInt();
        while (!isValidMinutes(minutes)) {
            System.out.println("Enter minutes from 0 to 1440:");
            minutes = scanner.nextInt();
        }
        return minutes;
    }

    public static boolean isValidMinutes(int minutes) {
        return minutes >= 0 && minutes <= 1440;
    }

    public static String formatDuration(int minutes) {
        return minutes / 60 + " h " + minutes % 60 + " min";
    }

    public static double averagePerDay(int total, int days) {
        return (double) total / days;
    }

    public static void printSummary(int totalMinutes, int days) {
        System.out.println("Total: " + formatDuration(totalMinutes));
        System.out.println("Daily average: "
            + averagePerDay(totalMinutes, days) + " min");
        if (totalMinutes >= 150) {
            System.out.println("Weekly goal reached");
        }
    }
}

For integer input, readMinutes repeats its range check until the number is valid. With daily inputs 30, 45, 0, 60, 90, 45, and 45, the total is 315. Formatting gives "5 h 15 min", the average is 45.0 minutes, and the program reports that its weekly goal of 150 minutes is reached.

Check small methods and their boundaries

Call each calculation with known results. formatDuration(0) should give "0 h 0 min", 59 gives "0 h 59 min", 60 gives "1 h 0 min", and 135 gives "2 h 15 min". The inputs just below and at 60 check the change from minutes to a whole hour.

For isValidMinutes, test -1, 0, 1440, and 1441. The expected results are false, true, true, and false. Printing expected and actual values side by side makes an error visible. JUnit automates this style of check.

Bottom-up development starts by writing and testing small helpers, then joins them into larger steps. You can plan top-down and build bottom-up: settle the data flow first, prove the small calculations work, then check the connected program.