Answer.

(a) By using a named constant such as INTEREST_RATE instead of a literal constant value such as 0.03, you make the program easier to read, since the symbolic name is more meaningful than the number. Furthermore, it is easier to change the value of a named constant (between runs of the program, of course): When using a named constant, there is only one place in the program where you have to change the value, the point where the named constant is declared. When using a literal constant, you would have to hunt down every place in the code where the value is used, and change each occurrence of the constant to the new value.

(b) Variables in Java such as p and q do not hold objects. They only hold pointers or references to objects. When you compare variables using == or !=, you are testing whether the values stored in the two variables are equal or not. That is, we are testing whether or not the two variables point to the same object. We are not testing the contents of the objects to which p and q point. That is, it is possible that p and q point to different objects but that all the data values in the two objects are identical. In that case, p == q is false, since they point to different objects, even though the contents of the two objects are equal.

(c) Getters and setters are instance methods in objects that allow the user to read and change the values of properties of the objects. Generally, the properties are private instance variables. The purpose is to give the user of the object some access to the variable while maintaining complete control over exactly what can be done with the variable. For example, a setter method can make sure that the value of a property can never be set to an illegal value.

Answer.

B[0]:   3
B[1]:   4
B[2]:   6
B[3]:   11
B[4]:   13
B[5]:   23

(The first line just sets B[0] to be the same value as A[0], so the first item in B is 3. After that, the value of B[i] is computed as B[i-1]+A[i]. B[i-1] is the value before B[i] in the B array, while A[i] is the value next to B[i]. For example, B[1] = B[0]+A[1] = 3+1 = 4. And B[2] = B[1]+A[2] 4+2 = 6.)

Answer.

public static boolean almostEqual( double x, double y) {
    if ( Math.abs( x - y ) < 0.000005 ) {
        return true;
    }
    else {
        return false;
    }
}

(The names of the parameters can be anything, "public" is optional, and the body of the routine can be written in other ways -- such as, "return (Math.abs(x-y)<0.000005);" -- but the "static boolean almostEqual" must be exactly as shown.)

Answer.

public static void countLetters( String str ) {
    str = str.toUpperCase();  // so I only have to check upper case letters
    for (char ch = 'A'; ch <= 'Z'; ch++ ) {
        int count = 0;
        for ( int i = 0; i < str.length; i++ ) {
            if ( str.charAt(i) == ch ) {
                count++;
            }
        }
        System.out.println(ch + ": " + count);
    }
}

Answer.

double average;  // the average of the positive numbers in the array

double sum;  // sum of positive numbers in the array
int count;   // the number of positive numbers in the array.
sum = 0;
count = 0;

for (int i = 0; i < numbers.length; i++) {
    if (numbers[i] > 0) {
        count++;
        sum += numbers[i];
    }
}

average = sum/count;

(Note: If the number of positive numbers in the array is zero, then the average will be computed as Double.NaN. I did not expect you to detect or avoid this case.)

Answer.

     Point pt1, pt2, pt3;    // Declare the three variables.
     
     pt1 = new Point();  // Create an object for p1 to point to
     pt2 = pt1;          // Make p2 point to the same object
     pt3 = new Point();  // Create an object for p3 to point to

     pt1.x = 15;    // Assign values to instance variables in pt1
     pt1.y = 3;

     pt3.x = 17;    // Assign values to instance variables in pt3
     pt3.y = 42;

Answer.

     for (int i = 0; i < 100; i++) {
         if ( inventory[i].numberInStock == 0 ) {
             System.out.println( inventory[i].name );
         }
     }

Answer. The job of paintComponent[] is to draw on the screen, basing the drawing on the current state.

In more detail: paintComponent is an instance method in a JPanel (or other GUI component) that is called by the system whenever the contents of the panel need to be drawn. (This happens when a window first appears on the screen or when repaint() is called.) Its purpose is to draw the contents of the panel. To do this, it uses the state of the program (that is the values of variables) to decide what to draw.

Answer. (b) creates an array of length 10 that can hold pointers to 10 objects of type Foo, but is initially filled with null values. (a) creates a new object of type Foo; the class Foo must have a constructor that takes one parameter of type int (or some other numeric type).

Answer. A subroutine is a self-contained unit of code for performing some task, but in order for it to do anything useful, there has to be some communication between the subroutine and the rest of the program.

Usually, a task has inputs. For example, if the task is to draw a rectangle, then the task needs to know the position and size of the rectangle. Such inputs can be passed into the subroutine as parameters. Values for parameters are provided when a subroutine is called. For example, the statement g.drawRect(100,100,50,150); contains four "actual parameter" values. These values are passed into the subroutine and become the values of "dummy parameters" inside the subroutine.

In some cases, a subroutine needs to send some output value back to the rest of the program for further processing. The subroutine is said to "return" the value, and subroutines that return a value are called functions. For example, the function Math.sqrt(2) returns a value representing the computed square root of the parameter 2. This answer can, for example, be assigned to a variable or used in a more complicated expression.

Subroutines also have access to global variables, that is variables that are declared outside of any subroutine. Global variables store the "state" of the program -- information that persists between calls to subroutines. It is possible for one subroutine to change the value of a global variable, and then other subroutines will be able to see that value. It can be reasonable for subroutines to manipulate the global state of the program, but it should not be done simply to pass information between subroutines that could be sent as parameter values or return values.