Java, Java, Java

The program in Figure 9.5 creates two arrays of ten elements each and displays their values on the Java console. In this example, the elements

,,

 

 

 

 

 

 

 

 

 

 

 

 

J

Figure 9.5: A program that displays two arrays. Its output is shown in Figure 9.6

 

of intArr have not been given initial values whereas the elements of

realArr have been initialized. Note the use of the integer constant

 

 

 

 

Maintainability principle

ARRSIZE to store the arrays’ size. By using the constant in this way, we do not have to use the literal value 10 anywhere in the program, thereby making it easier to read and to modify the program. If we want to change the size of the array that the program handles, we can just change the value of ARRSIZE. This is an example of the maintainability principle.

 

 

 

Note the use of the static qualifier throughout the PrintArrays class. This enables us to refer to the array and the other variables from within the main() method. If intArr were not declared static, we would get the compiler error attempt to make static use of

a non-static variable. This use of static is justified mainly as

 

IntsReals

01.1

02.2

03.3

04.4

05.5

06.6

07.7

08.8

09.9

010.1

 

 

 

 

 

 

 

 

 

1 4 9 16 25

36 49 64 81 100

121 144 169 196 225

256 289 324 361 400

441 484 529 576 625

676 729 784 841 900

961 1024 1089 1156 1225

1296 1369 1444 1521 1600

1681 1764 1849 1936 2025

2116 2209 2304 2401 2500

FIGURE 9.8Output of the

Squares program.

Zero vs. unit indexing

a coding convenience rather than a principle of object-oriented design. The only examples we’ve seen so far in which static elements were a necessary design element were the use of static elements in the Math class—Math.PI and Math.sqrt()—and the use of static final variables in TwoPlayerGame—TwoPlayerGame.PLAYER ONE.

For large arrays, it is not always feasible to initialize them in an ini-

tializer statement. Consider the problem of initializing an array with the squares of the first 100 integers. Not only would it be tedious to set these values in an initializer statement, it would also be error prone, since it is relatively easy to type in the wrong value for one or more of the squares.

 

 

 

The example in Figure 9.7 creates an array of 50 integers and then fills the elements with the values 1, 4, 9, 16, and so on. It then prints the entire array.

This example illustrates some important points about the use of array variables. The array’s elements are individual storage locations. In this example, intArr has 50 storage locations. Storing a value in one of these variables is done by an assignment statement:

,,

J

The use of the variable k in this assignment statement allows us to vary the location that is assigned on each iteration of the for loop. Note that in this example, k occurs as the array index on the left-hand side of this expression, while k+1 occurs on the right-hand side as the value to be squared. The reason for this is that arrays are indexed starting at 0 but we want our table of squares to begin with the square of 1. So the square of some number n+1 will always be stored in the array whose index is one less than the number itself—that is, n.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

J

Figure 9.7: A program with an array that stores the squares of the first 50 integers. Its output is shown in Figure 9.8.

 

An array’s length variable can always be used as a loop bound when iterating through all elements of the array:

,,

 

J

However, it is important to note that the last element in the array is always

at location length-1. Attempting to refer to intArr[length] wouldOff-by-one error

cause an IndexOutOfBoundsException because no such element ex- ists.

 

 

SELF-STUDY EXERCISE

EXERCISE 9.6Declare an array of 100 doubles and write a loop to as- sign the first 100 square roots to its elements. [Use Math.sqrt(double).]