CS 1401, Exam #4

Date: Wednesday, November 22, 2006, 9:30 am
Name (please type legibly, ideally in block letters): ______________________________________________________________________

1. Define a class Turkey in which each object has two parameters: the weight of the turkey, and the price (both integers). Do not forget to include a constructor method, accessor methods, mutator methods, and a method that computes an (integer-valued) price per pound.

Solution:

public class Turkey{
  protected int weight;
  protected int price;
  public Turkey(int aweight, int aprice)
    {weight = aweight; price = aprice;}
  public int getWeight(){return weight;}
  public int getPrice(){return price;}
  public void setWeight(int newWeight){weight = newWeight;}
  public void setPrice(int newPrice){price = newPrice;}
  public int pricePerPound(){return price / weight;}
}

2. Considering the class Turkey (defined in Problem 1) as a superclass, define a subclass ThanksgivingTurkey in which each object has an additional field: the weight of stuffing. Overwrite the original price-per-pound method: it should now divide the cost by the total weight of the turkey and of the stuffing (i.e., by the sum of the two weights).


Solution:

public class ThanksgivingTurkey extends Turkey{
  private int weightOfStuffing;
  public ThanksgivingTurkey(int aweight, int aprice, int aweightOfStuffing)
    {super(aweight, aprice); weightOfStuffing = aweightOfStuffing;}
  public int getWeightOfStuffing(){return weightOfStuffing;}
  public void setWeightOfStuffing(int newWeightOfStuffing)
    {weightOfStuffing = newWeightOfStuffing;}
  public int pricePerPound()
    {return price / (weight + weightOfStuffing);}
}

3. In the main method, define a new object of type ThanksgivingTurkey (as defined in Problem 2). This object should describe a turkey that weighs 20 pounds, has 5 pounds of stuffing, and costs $26. Use the price-per-pound method to compute and print the pre-pound cost of this turkey.


Solution:

ThanksgivingTurkey myTurkey = new ThanksgivingTurkey(20, 26, 5);
int result = myTurkey.pricePerPound();
System.out.println(result);

4. Trace your code from Problem 3 step-by-step.


Tracing:

on the first line, we call a constructor method:

 -----------------
|  -------------  |
| |    20       | |
|  -------------  |
|    aweight      |
|  ------------   |
| |    26      |  |
|  ------------   |
|    aprice       |
|  ------------   |
| |    5       |  |
|  ------------   |
| aweightPerPound |
|-----------------|
|                 |
|                 |
|                 |
|                 |
|                 |
|                 |
|                 |
|                 |
 -----------------
 ThanksgivingTurkey

this method, in its turn, calls a constructor method of the superclass:

 -----------------
|  -------------  |
| |    20       | |
|  -------------  |
|    aweight      |
|  ------------   |
| |    26      |  |
|  ------------   |
|    aprice       |
|-----------------|
|                 |
|                 |
|                 |
|                 |
|                 |
|                 |
|                 |
|                 |
 -----------------
      Turkey

after the first line, we get a new object

 -----------------
|  -------------  |
| |    20       | |
|  -------------  |
|     weight      |
|  ------------   |
| |    26      |  |
|  ------------   |
|     price       |
|  ------------   |
| |    5       |  |
|  ------------   |
|  weightPerPound |
|-----------------|
|                 |
|                 |
|                 |
|                 |
|                 |
|                 |
|                 |
|                 |
 -----------------
     myTurkey

after the second line, we get

 ----------
|   1     |
 ----------
   result


5. Modify the price-per-pound method from Problem 2 as follows: use try/catch block to produce a meaningful error message when the total weight is 0.


Solution:

  public int pricePerPound()
    {try{
      return price / (weight + weightOfStuffing);
     }
    catch(ArithmeticException a){
      System.out.println("Total weight is 0, so price-per-pound is undefined.");
    }
  }

6. Write a method that, given an array h of integers, computes the smallest element of this array. Test your method step-by-step on a numerical example.


Solution:

public int smallest(int[] h){
  int smallestSoFar = h[0];
  for(int i = 1; i < h.length; i++)
    {if (h[i] < smallestSoFar) smallestSoFar = h[i];}
  return smallestSoFar;
}

Testing:

in the main method:

int[] z = {2, 4, 0};
int small = smallest(z);

tracing:

First, we define an array

 ----
|  \|
 ---\
  z  \
      \|
      - -------
       |   2  |  z[0]
        -------
       |   4  |  z[1]
        -------
       |   0  |  z[2]
        -------

Then, we call a method:

 ---------------------------
|    ----                   |
|   |  \|                   |
|    ---\                   |
|     h  \                  |
|         \|                |
|         - -------         |
|          |   2  |  h[0]   |
|           -------         |
|          |   4  |  h[1]   |
|           -------         |
|          |   0  |  h[2]   |
|           -------         |
|---------------------------|
|                           |
|          ...              |

Within this method, we define a new variable smallestSoFar and assign
it a value h[0] = 2:

 ---------------------
|        2            |
 ---------------------
    smallestSoFar

Then, we start a loop by defining a new variable i and assigning it
a value 1:

 ---------------------      ---------
|        2            |    |    1    |
 ---------------------      ---------
    smallestSoFar               i

Since 1 = i < h.length = 3, we go inside the loop. Since i = 1, the
condition 4 = h[1] < smallestSoFar = 2 is not satisfied, so we do not
do anything inside the loop. Next, we increase i by 1:

 ---------------------      ---------
|        2            |    |    2    |
 ---------------------      ---------
    smallestSoFar               i

Since 2 = i < h.length = 3, we go inside the loop. Since i = 2, the
condition 0 = h[2] < smallestSoFar = 2 is satisfied, so change the
value of smallestSoFar to h[2] = 0:

 ---------------------      ---------
|        0            |    |    2    |
 ---------------------      ---------
    smallestSoFar               i

Next, we increase i by 1:

 ---------------------      ---------
|        0            |    |    3    |
 ---------------------      ---------
    smallestSoFar               i

Now, 3 = i is not smaller than h.length = 3, so we exit the loop, and
return the value smallestSoFar = 0 to the line

int small = smallest(z);

according to which the value 0 is assigned to the new variable small:

 -------------
|     0       |
 -------------
    small