Static Subroutines and Variables in Java

A subroutine is a block of code that can be called multiple times from different parts of a program. Before you use one, you need to know what it promises and what it needs. Experienced programmers rarely read the body of a subroutine first. They read the header, the line that comes before the braces and the code inside them. The header describes how the subroutine can be used: what it is, what it hands back, and what it needs to be given. You can think of the header as a short contract between the subroutine and anyone who calls it.

Read a header from left to right and you meet three kinds of information in order. First come the modifiers at the front, words such as static or public that set characteristics of the subroutine. Next comes the return type, which describes what kind of value the subroutine gives back, or the word void when it gives back nothing. After the return type comes the subroutine's name. The parameter list sits last, inside the parentheses that follow the name. For each piece, ask the same question: what does this part promise or require when someone uses the subroutine?

The diagram labels each piece of one header. Reading it once, you learn that the subroutine is public and static, that it hands nothing back because of void, that it is called printTable, and that it needs one int value, which it will refer to as n inside its body. You learned all of that without reading a single line of the body.

Modifiers are the words that can appear at the start of a subroutine definition, before the return type. Their job is to set characteristics of the subroutine. The source names static and public as the two modifiers it has encountered so far, and it highlights whether a subroutine is static as one such characteristic. Modifiers change how a subroutine behaves or is accessed. They do not change what the subroutine computes.

A helpful way to hold this idea is to treat each modifier as an answer to a yes-or-no or which-kind question. One question is whether the subroutine belongs to the class as a whole rather than to one object. Another is whether it is open for outside code to call. Notice what modifiers do not answer. They do not describe the values the subroutine accepts or returns. Those jobs belong to the return type and the parameter list.

The return type sits between the modifiers and the subroutine's name, and it depends on what kind of subroutine you are writing. A function is a subroutine whose job is to compute some value. For a function, the return type names the type of value that comes back to the caller. That type can be a type name such as String or int, or an array type such as double[]. If the subroutine is not a function, it does not hand a value back. In that case the return type position holds the special word void, which indicates that the return value is empty or non-existent.

The word void carries a promise of its own. When a header says void, callers should not expect any result from that subroutine. When a header names a type, callers should expect a value of that type to come back. Reading the return type therefore tells you immediately whether the subroutine can be used inside an expression that needs a value.

The parameter list sits inside the parentheses that follow the subroutine's name. Parameters carry information from outside the subroutine into it, so that its internal computations have something to work with. The source calls parameters part of the interface of a subroutine, meaning they are the part callers must match when they use it. A parameter declaration has the form type followed by parameter name, and the parameter list can be empty.

Consider a television with a method that changes the channel. The method needs to know which channel to switch to, so it needs an input. If a channel number is an integer, the parameter's type is int. The parameter is the spot in the header where the subroutine says what kind of input it expects and gives that input a name it can use inside its body.

A subroutine runs when the program calls it, not merely because it exists in the file. The important word is called. Because the same block can be called more than once, one piece of code can serve many moments in a single run. In the Printer program above, main calls printTable three times. Each call transfers control into printTable, the body runs with n set to the value passed in, and then control returns to main so that main can continue with its next line.

Read the diagram from top to bottom to trace one run. Main starts, then reaches its first call, and control moves into printTable with n equal to 3. When the body finishes, control returns to main at the line just after that call. The same pattern repeats for the second and third calls. The body of printTable was written once, but it ran three times, each time with a different value for n.

The source points to ThreeN2.java as a concrete program that uses subroutines. It is introduced in Section 4.4 as an improved version of the 3N+1 program, and the source describes it as a program that uses subroutines and prints its output in neat columns. The source gives two reasons for this design. The first is code organization: separating work into named blocks makes the program easier to read and manage. The second is output formatting: the program prints its results in neat columns, and subroutines are part of how that formatting is achieved.