Chapter 8 Review Exercise Solutions
R8.1
class VendingMachine to display available products
class Product to represent the each product in the machine
class Coin to represent coin values such as quarters, nickels, etc.
R8.2
class PayCheck to represent a pay check object, the total hours of work plus any overtime paid over a period of time
class Employee to represent each employee and hours worked
R8.3
class Customer handles the information of a customer object, its shipping and billing addresses. 
class Invoice lists the products that the customer ordered, records payments and calculates the amount due. 
class Product represents the name of the products and the amount it costs. 
class Address represents the shipping and billing addresses of each customer.
R8.4
The System class is not cohesive because it includes many features that are unrelated, such as console I/O, garbage collection, and the time in milliseconds.
R8.5

R8.6

R8.7
The Integer class depends on the String class.
R8.8
The class Rectangle depends on the Rectangle2D, Point, Dimension, and String classes.
R8.9
boolean hasNext() – Accessor 
boolean hasNextDouble() – Accessor 
boolean hasNextInt() – Accessor 
boolean hasNextLine() – Accessor 
String next() – Mutator 
double nextDouble() – Mutator 
int nextInt() – Mutator 
String nextLine() – Mutator
R8.10
Accessor methods:

contains
createIntersection
createUnion
equals
getBounds
getBounds2D
getHeight
getLocation
getSize
getWidth
getX
getY
intersection
intersects
isEmpty
outcode
toString
union

Mutator methods:

add
grow
setBounds
setLocation
setRect
setSize
translate
R8.11
Of the three class, Rectangle, String, and Random, only class String is immutable.
R8.12
Of the three classes PrintStream, Date, and Integer, the Integer class is immutable.
R8.13
public void print() 
The side effect is using System.out to print on the console.
public void print(PrintStream stream)
The side effect is modifying the stream parameter.
public String toString()
There is no side effect.
R8.14
If no function (including main) has a side effect, then you could not observe the program doing anything. Such a program would be useless. (Note that producing output on the screen is a side effect.)
R8.15
/**
   Computes the square root of a number.
   @param x the number
   @return the square root
   (Precondition: x >= 0)
*/
public static double sqrt(double x)

/**
   Converts an integer to its Roman numeral form.
   @param n the integer to be converted
   @return the Roman numeric equivalent
   (Precondition: n > 0)
*/
public static String romanNumeral(int n)

/**
   Computes the slope of a line. The line should not be vertical.
   @param a the Line object
   @return the slope
   (Precondition: a is not vertical)
*/
public static double slope(Line2D.Double a)

/**
   Converts a day into its English name form.
   @param day the day (0 = Monday, 1 = Tuesday, . . . , 6 = Sunday)
   @return the English name form of the day
   (Precondition: day < 7 && day >= 0)
*/
public static String weekday(int day)
R8.16
Math.sqrt: Argument is non-negative 
Math.tan: Argument is an angle in radians 
Math.log: Argument is positive 
Math.pow(double x, double y): (x > 0, or x = 0 and y > 0, or x < 0 and y is an integer) 
Math.abs: No precondition
R8.17
a.	Integer.parseInt(String s): The string can be interpreted as an integer
b.	StringTokenizer.nextToken(): hasMoreTokens() must be true
c.	Random.nextInt(int n): n > 0
d.	String.substring(int begin, int pastEnd): 
begin >= 0 && pastEnd <= String.length() && begin <= pastEnd
that is,
begin  0 and pastEnd  String.length() and begin  pastEnd
R8.18
The Math.tan method returns NaN if its argument is infinity. 
The Math.sqrt method returns a NaN value if its argument is less than 0.
The Integer.parseInt method throws an exception when its argument is not a string that denotes an integer.
The String.substring method throws an exception when its arguments do not denote the bounds of a substring.
R8.19
/**
   Enters a payment in the CashRegister.
   @param coinCount how many coins are being entered
   @param coinType the type of coins being entered
   (Precondition: coinCount > 0 and coinType is a valid type)
   (Postcondition: getTotalPayment() > 0)
*/
public void enterPayment(int coinCount, Coin coinType)
R8.20
When you call falseSwap, then a is initialized with 3 and b is initialized with 4. At the end of the falseSwap method, a is 4 and b is 3. Then the method exits and its local variables (including the parameter variables) are forgotten. The contents of x and y are not affected.
R8.21
public static void swap(Point2D.Double p)
{
   p.setLocation(p.getY(), p.getX());
}
public static void main(String[] args)
{
   double x = 3;
   double y = 4;
   Point2D.Double p = new Point2D.Double(x, y);
   swap(p);
   x = p.getX();
   y = p.getY();
   System.out.println(x + " " + y);
R8.22

R8.23

R8.24
We get the error message "non-static method print(int) cannot be referenced from a static context" because the print method is not declared as static. If you change the header of the method to public static void print(int x), then the program will work. The reason the method needs to be declared as static is because we are calling it without an object reference (implicit parameter), but only static methods can be called like that.
R8.25
decode
getInteger
highestOneBit
lowestOneBit
numberOfLeadingZeros
numberOfTrailingZeros
parseInt
reverse
reverseBytes
rotateLeft
rotateRight
signum
toBinaryString
toHexString
toOctalString
toString // all of the toString variations, except toString()
valueOf

They are static methods because these methods do not need an implicit parameter.
R8.26
All of the valueOf methods in the String class are static methods. Like the methods in the Integer class, these methods are static because these methods do not operate on an object and have only explicit parameters. They create a new String instead of modifying an existing String (implicit parameter, which these methods do not need). The format methods are also static, for the same reason.
R8.27
It is not a good design because using public static variables is not a good idea; they can accidentally get overwritten in large programs. A better way to do this is to have static methods System.getIn() and System.getOut() that return these streams.
R8.28
In the following class, all of the declarations of n are legal except for 2. See comments below.
public class X
{
   private int n;

   public int f()
   {
      int n = 1;
      return n;
   }

   public int g(int k)
   {
      int a;
      for (int n = 1; n <= k; n++)
         a = a + n;
      return a;
   }

   public int h(int n)
   {
      int b;
      for (int n = 1; n <= 10; n++) // illegal
         b = b + n;
      return b + n;
   }

   public int k(int n)
   {
      if (n < 0)
      {
         int k = -n;
         int n = (int) (Math.sqrt(k)); // illegal
         return n;
      }
      else return n;
   }

   public int m(int k)
   {
      int a;
      for (int n = 1; n <= k; n++)
         a = a + n;
      for (int n = k; n >= 1; n++)
         a = a + n;
      return a;
   }
}
R8.29
To write a Java program without import statements, the user needs to specify the path names of the classes that are used in the program.
/**
   A component that draws two rectangles.
*/
public class RectangleComponent extends javax.swing.JComponent 
{  
   public void paintComponent(java.awt.Graphics g)
   {  
      // Recover Graphics2D
      java.awt.Graphics2D g2 = (java.awt.Graphics2D) g;

      // Construct a rectangle and draw it
      java.awt.Rectangle box = new java.awt.Rectangle(5, 10, 20, 30);
      g2.draw(box);

      // Move rectangle 15 units to the right and 25 units down
      box.translate(15, 25);

      // Draw moved rectangle
      g2.draw(box);
   }
}
R8.30
The default package is the package that contains the classes with no package specifier. All classes that we have programmed up to this point were in the default package.
R8.31
The exception is reported, and the remaining methods continue to be executed. This is an advantage over a simple tester class whose main method would terminate when an exception occurs, skipping all remaining tests.