Subroutines and Parameters

Suppose a program needs the same job done in three different places. One option is to copy the same lines of code three times. The other option is to write those lines once and let the rest of the program use them whenever they are needed. The second option is what a subroutine provides. A subroutine is a block of code that can be called multiple times from different parts of a program.

The important word in that definition is called. A subroutine does not run just because it exists in a program. It runs when the program reaches a point where it calls it. Because the same block can be called more than once, a single piece of code can serve many moments in one run of the program.

Before reading on, ask yourself this question: if a program needs the same calculation or the same printed output in several places, where would you rather keep the instructions for it, in one place or in every place it is needed? The main idea of subroutines is an answer to that question.

A functional interface is a Java file that holds a specification for exactly one subroutine. It is defined in a .java file just as a class is. Before looking at a real declaration, make a prediction. Think about how much of the file is about how the subroutine actually computes its answer, and how much is only about the shape of a call to it.

The source gives a first example as a whole functional interface squeezed onto one line. It is saved in a file named FunctionR2R.java, which matches the name of the interface, as with any Java class. The declaration has the following shape, read from left to right: the interface is named FunctionR2R, and inside the braces there is one line that names a subroutine called valueAt.

The specification records three facts about the subroutine: its name (valueAt), its parameters (how many and of what type, here one double), and its return type (here double). The source notes that a parameter name such as x is written in the declaration but is not really part of the specification. When you check a call against the specification, compare the number of parameters and their types, not the names.

Now consider how a main program uses that subroutine. The example below is an original illustration, not taken from the source. Suppose the main program calls valueAt three times at different points in its run. Each call pauses the main program, runs the subroutine, and then returns control to the line of main that made the call. Control moves back and forth between main and the subroutine in this order.

Notice that there is only one definition of valueAt, yet it is invoked three times. Each invocation starts from the same specification, and each one returns to the point in main where it was called. The main program continues its own statements after each return, so the three results can be used in different ways later in the run.

Once you know the three facts, you can debug a broken use of a subroutine by asking where the use departs from the specification. Suppose some code calls valueAt with two numbers instead of one. The specification says there is one double parameter, so the mismatch is in the number of parameters. You do not need to guess. Compare the call against the declaration line by line.

The source gives a second example with a different shape. It describes a subroutine that does not return anything and takes two parameters, an array of strings and an int. The source does not supply a name for this subroutine in the excerpt, so the example here focuses on its shape rather than a specific identifier.

A return type of void is still a return type. It tells the caller that no value comes back from the subroutine. The shape of the specification never changes; only the values placed into each part of it do.

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 does not list the individual subroutines inside the file or show their code, so this article does not describe them in detail.