1. Define a class Pie in which each object has two parameters: weight of the pie (in ounces), and the number of people served (both integers). Do not forget to include a constructor method, accessor methods, mutator methods, and a method that computes the (integer-valued) amount per person served.
Solution:
public class Pie{
protected int weight;
protected int number;
public Pie(int aweight, int anumber)
{weight = aweight; number = anumber;}
public int getWeight(){return weight;}
public int getNumber(){return number;}
public void setWeight(int newWeight){weight = newWeight;}
public void setNumber(int newNumber){number = newNumber;}
public int amountPerPerson(){return weight / number;}
}
2. Considering the class Pie (defined in Problem 1) as
a superclass, define a subclass PumpkinPie in which
each object has an additional field: the weight of the frosting.
Overwrite the original amount-per-person method: it should now divide
the total weight of the pie and of the frosting by the number of persons
served.
Solution:
public class PumpkinPie extends Pie{
private int frosting;
public PumpkinPie(int aweight, int anumber, int afrosting)
{super(aweight, anumber); frosting = afrosting;}
public int getFrosting(){return frosting;}
public void setFrosting(int newFrosting)
{frosting = newFrosting;}
public int amountPerPerson()
{return (weight + frosting) / number;}
}
3. In the main method, define a new object of type
PumpkinPie (as defined in Problem 2).
This object should describe a pumpkin pie
that weighs 20 ounces, has 5 ounces of frosting,
and serves 5 persons. Use the amount-per-person method to compute and print the
amount per person served.
PumpkinPie myPie = new PumpkinPie(20, 5, 5); int result = myPie.amountPerPerson(); 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 |
| ------------ |
| | 5 | |
| ------------ |
| anumber |
| ------------ |
| | 5 | |
| ------------ |
| afrosting |
|-----------------|
| |
| |
| |
| |
| |
| |
| |
| |
-----------------
PumpkinPie
this method, in its turn, calls a constructor method of the superclass:
-----------------
| ------------- |
| | 20 | |
| ------------- |
| aweight |
| ------------ |
| | 5 | |
| ------------ |
| anumber |
|-----------------|
| |
| |
| |
| |
| |
| |
| |
| |
-----------------
Pie
after the first line, we get a new object
-----------------
| ------------- |
| | 20 | |
| ------------- |
| weight |
| ------------ |
| | 5 | |
| ------------ |
| number |
| ------------ |
| | 5 | |
| ------------ |
| frosting |
|-----------------|
| |
| |
| |
| |
| |
| |
| |
| |
-----------------
myPie
after the second line, we get
----------
| 5 |
----------
result
5. Modify the amount-per-person method from Problem 2 as follows:
use try/catch block to produce
a meaningful error message when the number of persons served is 0.
Solution:
public int amountPerPerson()
{try{
return (weight + frosting) / number;
}
catch(ArithmeticException a){
System.out.println("Number of persons served is 0, so amount-per-person is undefined.");
}
}
6. Write a method that, given an array
h of integers,
computes the largest element of this array. Test your method
step-by-step on a numerical example.
Solution:
public int largest(int[] h){
int largestSoFar = h[0];
for(int i = 1; i < h.length; i++)
{if (h[i] > largestSoFar) largestSoFar = h[i];}
return largestSoFar;
}
Testing:
in the main method:
int[] z = {2, 4, 0};
int large = largest(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 largestSoFar and assign
it a value h[0] = 2:
---------------------
| 2 |
---------------------
largestSoFar
Then, we start a loop by defining a new variable i and assigning it
a value 1:
--------------------- ---------
| 2 | | 1 |
--------------------- ---------
largestSoFar i
Since 1 = i < h.length = 3, we go inside the loop. Since i = 1, the
condition 4 = h[1] > largestSoFar = 2 is satisfied, so we change the
value of largestSoFar to h[2] = 4:
--------------------- ---------
| 4 | | 1 |
--------------------- ---------
largestSoFar i
Next, we increase i by 1:
--------------------- ---------
| 0 | | 2 |
--------------------- ---------
largestSoFar i
Since 2 = i < h.length = 3, we go inside the loop. Since i = 2, the
condition 0 = h[0] > largestSoFar = 2 is not satisfied, so we do not
do anything. Next, we increase i by 1:
--------------------- ---------
| 4 | | 3 |
--------------------- ---------
largestSoFar i
Now, 3 = i is not smaller than h.length = 3, so we exit the loop, and
return the value largestSoFar = 4 to the line
int large = largest(z);
according to which the value 4 is assigned to the new variable large:
-------------
| 4 |
-------------
large