Arrays and Indexing

Most methods are written with a fixed list of parameters, so every call has to supply exactly that many values. A variable arity method removes that restriction. It is written once, but a caller may pass a different number of actual parameters each time it is invoked. This article answers one question: when a method accepts a varying number of inputs, how does the body of that method actually get hold of them?

The short answer is that the language does not hand the method a loose, unknown collection of values. It packages them into a single structure that the body can inspect. Before reading on, pause and predict what that single structure might be. Then follow one call step by step and check your guess.

Follow a single call. At the call site, the caller writes the actual parameters that correspond to the variable arity parameter. Suppose the caller supplies three values: 4.0, 7.0, and 9.0. When the method is called, the values of all three actual parameters are placed into an array. It is that array, not the three separate values, that is actually passed to the method.

The diagram shows the key point of the whole mechanism. Several separate values at the call site become one array argument. The method therefore receives a single value of array type, and the body has to work with that array to see the individual values. Notice that the method never sees the three values as three separate parameters. It sees one array holding them.

Inside the method body, a variable arity parameter of type T looks like an ordinary parameter of type T[]. The declaration in the method header uses the variable arity form, but once execution is inside the body, the parameter behaves as a plain array of that element type. This is why the body does not need any special machinery to handle a variable count. It uses the same tools it would use on any array: a length, and indexed access to each element.

Think of the variable arity parameter as a container that the language fills at the call site. Its declared type tells the reader that values of type T may be supplied. Its runtime form inside the body is T[], so every operation that works on arrays works on it too.

The source uses a method that works with a list of numbers and computes their average as its running example. In the body of that method, the array is named numbers and has type double[]. Two pieces of information come directly from it. The number of actual parameters in the call is numbers.length, and the individual values are numbers[0], numbers[1], and so on, up to the last valid index.

This body is an original illustration of how the two facts combine. It totals every element by walking the indices from zero up to the length, then divides by the count. Nothing here is new syntax; it is ordinary array code that happens to operate on the array the method received.

Notice that the length is a property of the array as a whole, not something the caller has to pass separately. Because the count travels with the array, the body can always find out how many values it received without any extra parameter describing the count. That is why the signature needs only the variable arity parameter and nothing else to carry the count.

What happens when the caller supplies no values for the variable arity parameter? The same mechanism applies. The values that the caller supplied for that parameter are placed into an array, and in this case there are none to place. The body therefore receives an array whose length reflects zero supplied values. The length check is the way the body detects this situation.