Writing Methods With Parameters

Imagine you have written a method designed to take any number of numbers and compute their average. A caller can list the values one by one. But suppose the values already sit together in an array, perhaps because they were read from a file or collected in a loop. Must the caller unpack that array into separate values before making the call? The answer shapes how you will write and read every call to a method of this kind.

This article answers that question. The key fact is that a method can be written to accept a variable number of arguments, and that a caller has two legal ways to supply them. You can list the individual values, or you can pass one array that already holds those values. The method body is the same in both cases, so understanding why will also show you how to read these methods.

Before looking at the rules in general, it helps to watch one complete call from start to finish. The example uses an averaging method that accepts any number of double values. The caller holds its data in an array. Read each step and ask two questions: what does the caller pass, and what does the method receive?

The diagram traces a single path. The values reach the call, they arrive inside the method as one parameter, and the method reads the elements of that parameter to produce a result. The walkthrough in the code above describes the same path, so a reader who follows either one should reach the same conclusion. Both calls produce the same kind of result because the values they supply are the same.

This is why a single array is a legal argument. The method was declared to receive its variable arity parameter as an array, so an argument that is already an array fits that parameter directly. The caller is not forced to take the values out of the array and list them again. Whether the caller listed the values one by one or handed over an existing array, the method can work with the values through that array.

Two calls, one method. The method accepts both forms because the parameter it declares is an array, and both forms supply values in the form that parameter expects. The method body does not need to know which form was used, because by the time the code inside runs, the values are available through the array.

Once the call is made, the method sees one array. Each value is reached through a position: index 0 is the first value passed, index 1 is the second, and so on up to the last position. The method reads those positions the way it would read any array, which is why the loop in the averaging method can walk through every value in order.

Because the parameter is an array, the length of the array is the number of values the method received. This is why the averaging method divides by values.length rather than by a fixed count. The same method therefore works for two values, four values, or any other number of values.

The same idea scales to more complicated parameter types. Consider a method that draws a polygon through any number of points, where each point is an object with two integer instance variables, x and y. Such a method has one ordinary parameter, the graphics context used for drawing, plus a variable arity parameter for the points. Inside the method, that parameter is an array of Point objects, so the method can loop over the points in order to connect them.

The choice between the two forms follows from how the data already exists. Use separate values when you have a few known numbers that you can name directly in the call. Use one array when the values are stored together, for example because they came from a file or were collected in a loop. Because both forms produce the same method behavior when the values match, you are choosing for readability and convenience rather than for correctness.