Declaring and Creating Arrays

Suppose a teacher wants a program that tracks thirty students in one class. Writing thirty separate variables, one per student, would be tedious, and it would make it hard to process the whole class with a single loop. An array solves this problem. An array stores many values of one type under a single name, and each value is reached through a numeric index written in square brackets.

So far in this course the values stored in an array have usually been primitives such as int or double. An array of objects follows exactly the same pattern, except that each element is an object of a class you have written, such as Student. A class of thirty students can then be modeled as one variable holding thirty Student objects, and any one student can be reached by writing an index in square brackets.

The work in this topic has three parts: declaring the array, filling it with objects, and then using each object. Most errors in this kind of code come from skipping or misordering one of those three parts. This article treats them as separate steps and asks you to predict the state of the program at each one, starting with a question you can answer before reading on.

Declaring an array variable gives the variable a type so that it can refer to an array. It does not create the array. The declaration tells the compiler what kind of thing the variable may refer to, but it does not supply that thing. A variable of an array type still needs a value before it can be used, and in this case the value has to be an array. The array must be created separately, using a special syntax.

The first statement in the Student example declares a variable named classlist that can refer to an array of Student objects. The second statement creates an array with thirty positions and makes classlist refer to it. These are two separate steps, and the first one alone leaves the program with no array to work with.

The before and after states differ in one important way. The variable exists in both, but only the second state has an array for it to refer to. Any code that uses classlist between these two statements is working with a variable that has no array yet, and that is the first place an unexpected result can begin.

An array type is built from two parts: the base type of the array, followed by a pair of empty square brackets. The base type is the type of each element the array will hold. The brackets mark the type as an array type rather than a single value of the base type. So the base type Student becomes the array type Student[], and the base type int becomes int[].

Read Student[] classlist; from left to right. Student is the base type, meaning the kind of element the array holds. The empty brackets [] carry the array marker. classlist is the name you will later use to reach the array.

Once you have the type, a variable is declared by writing the type, a space, and the variable name, followed by a semicolon. The same pattern applies to every base type. The table below lists the examples from the source and one further case of the same pattern.

Creating an array is the step that produces the actual array. In Java this is done with the operator new. The source notes that arrays in Java are objects, and the special syntax is related to this, although the details of object creation are not needed at this stage. What matters here is the pattern you write.

Read the second line from left to right. The array variable A is on the left of the assignment, so it receives the new array as its value. On the right, new is followed by the base type int and then a length in square brackets. The length is required, because creating an array means deciding how many elements it has. Here the length is 5, so A refers to an array of five elements.

Return to the question you were asked at the start. Right after new Student[30] runs, the array holds thirty positions, and each position is a reference to a Student object. At this stage none of those references points to a Student yet. The diagram shows the first four of the thirty positions. The same structure holds for every index from 0 to 29 once the loop has completed.

The array itself is only the set of these positions. Each Student object lives separately, and a slot only gets to refer to one when your code assigns it. That is why the array created by new Student[30] is described as an array of references rather than thirty Student objects. The source makes the same point: at this stage none of the references points to a Student yet.

Because each element must be initialized separately, the usual pattern is a loop that runs over every index and stores a new object in each position. The declaration and creation come first, and the loop follows. The loop variable i runs from 0 up to, but not including, 30, so it visits each valid index exactly once. The valid indexes of a thirty-element array are 0 through 29.

Notice what the diagram implies. Until the pass that handles a given index has run, that slot is still empty. A read of that slot at that moment does not reach a Student. The loop is therefore not a formality: the program is only safe to use the array once the loop has finished.

After initialization, classlist[i] behaves like any other variable of type Student. The index selects which object to work with, and the dot selects a field or method of that object. The source gives two examples. To read the name of student number 3, write classlist[3].name. To compute the average for student number i, call classlist[i].getAverage().

Read classlist[3].name from left to right. classlist[3] first selects the slot at index 3, which yields a reference. The dot then follows that reference into the Student object and reads its name. Each step depends on the one before it. If the slot at index 3 were still empty, the expression would fail at its first step, and the name field would never be reached.