Description

Goals and Background
This lab will give you some practice working with a class implementation, a test driver, and dealing with numeric computations. A note about this lab: Because this lab is a little long for the two-hour period (especially for less experienced students), we decided to make the lab only out of 3 points, even though there are four exercises here: so it’s possible to earn 4 points on this 3-point lab, but you should consider it completed if you do the first three exercises. The fourth one will be to give some students an extra challenge (definitely more of a challenge than the bonus problem on lab 2). You cannot get credit for Exercise 4 unless you have already completed exercises 1 – 3.
This lab is more difficult than the other ones you have had so far; to enable you to get it done in the two hour period we recommend you do some advanced preparation. Suggested preparation:
Remember to switch roles with your partner from what they were last time. For more information on lab partnerships, see Lab 2.
Reading and reference material
Horstmann, Ch. 3, Implementing Classes.
Horstmann, How To 3.1, Implementing a Class (Simpler Version of Cash Register Example is first presented here)
Horstmann, Section 4.1.1, Number types (Discusses roundoff errors)
Horstmann, Section 4.1.2, Constants (Enhancement of Cash Register — this is basically the version in this
lab — minor differences described in the comments in CashReg.java for this lab)
Horstmann, Section 4.2, Arithmetic
Horstmann, Section 4.2.5, Converting Floating-Point Numbers to Integers
Horstmann, How To 4.1, Carrying Out Computations (Vending machine example) Horstmann, Section 5.1, if Statements
Exercise 1 (1 checkoff point)
For this lab we have provided you with some starter files in Vocareum. There’s a separate subdirectory with the starter files for Exercise 4 (called ex4), because that involves different versions of the same classes.
This is a slightly modified version of the cash register class and test program developed in Section 4.1.2 of the textbook. (We just added one accessor method, some comments, and changed the name of the class slightly.) The two files you will be using are:
CashReg.java A cash register class. We added comments at the top of the class file to show how you might use it.
CashRegTester.java A test program for the cash register class. This one has a main method.
Compile and run the program to see what it does. You can compile and run a multi-file program such as this from the shell using a wild-card on the command line. This will compile all the .java files in the current directory.
javac *.java

Question 1.1.. The first set of tests has a sequence of two purchases recorded, a payment given, and then change given for that payment. Show a formula that describes how the expected result for the change given was arrived at for this first sequence. Show all purchase amounts and the payment amount in this formula. You will need to look at the code in CashRegTester.java to do this.

Following the conventions of output for the other tests already in CashRegTester.java, add a new test before the other tests in main with the following data:
the customer purchases one item for $4.35, and then pays with a 5 dollar bill, and the change is given.

Question 1.2.. You should have gotten a round-off error in your results. Why do you get such an error? (You don’t have to do any computations, just explain the issue.) Hint: this is discussed in section 4.1.1 of the textbook.

You can save the output from a run by redirecting it to a text file instead of sending it to the monitor. This is a feature of the Linux shell. You do it as follows:
java CashRegTester > ex1.out
Then you can examine the output at your leisure using the following Linux command:
more ex1.out or by loading it into the Vocareum edit window.
Save the output of exercise 1 as described above so you can compare it with results in the next exercise.
Exercise 2 (1 checkoff point)
Note: this lab exercise involves more thought and more code than other ones you have done. Because of some confusion about this exercise in past semesters, we have put some key points in bold below.
You will have multiple versions of this code floating around for this lab. Because the class names are required to correspond to the file names in java programs, it will be much easier to keep track of the various versions if they are each in a separate directory. So, before you start working on this exercise,
Make a subdirectory called ex2. Copy both of the files you used for exercise 1 into that subdirectory (i.e., the version of the code after you did exercise 1). Make ex2 your current directory.
Note: this and the following exercises will only involve making changes to CashReg.java; you are done making changes to CashRegTester.java.
One of the advantages of encapsulation (a.k.a., information hiding) we discussed in class is that you can change the internal representation of a class, and if the interface is unchanged all of the client code will still work, unmodified. Also, you will be able to test the new version of the class without modifying the old test program.
In this exercise you are going to make such a change to the internal representation of CashReg, without changing the interface at all. In fact, once you are done you should get the exact same results as the old version of CashReg, except for the problem from exercise 1.
The current version of the CashReg class stores all amounts in dollars using double variables. Change the implementation so that is uses amounts in cents instead (int). However, do not change the interface for the class; i.e., recordPurchase and giveChange still take parameters of type double, and getTotal returns a double. And these double values still signify some dollar amount.
So, for example, if purchase total at some point was $2.27, this would be represented inside the object by the number 227 (unit is cents), but the getTotal() method would still return 2.27 (interface didn’t change, so values returned are still in dollars — i.e., double).
Hints:
This is not just changing the types of a few variables, but will involve changing several parts of the class implementation, similar to when we made an enhancement to the Student class in lecture.
you will want to change the named constants in the program as well; additionally, you should add a constant called DOLLAR_VALUE.
if you get a compile error about losing precision from doing a computation with an int and a double, you can get it to compile by casting the result to be an int. See section 4.2.5 for how to type cast. Go ahead and do this.
When you run the new version of your code, you can see if it does the right thing by comparing it to the results of the old version. If you save your output to the file ex2.out (exercise 1 showed how to do this), you can compare the results using the Linux diff command:
diff ex2.out ../ex1.out
You should get the same exact output except for the test with the rounding error from exercise 1.
Question 2.1.. What results do you get for the test you added in exercise 1. Is this the right answer?
Exercise 3 (1 checkoff point)
Like last time, make a subdirectory of your work directory called ex3. Copy your code from the ex2 subdirectory into this new subdirectory.

Question 3.1.. Stating what directory you are starting from, show a single Unix command to copy the files as described.

Fix recordPurchase so it records the correct amount for values such as the one given in the first test in
CashRegTester. (So, just to review, we are talking about the version of the code that stores the necessary values in cents, rather than dollars.) When you run your program, save the results in ex3.out.
Hint: the Math.round function can be helpful here. It takes a double as a parameter (give it a double value). You want to use it such that the resulting rounded value will be the correct int for the value in cents.
Exercise 4 [optional] (1 checkoff point)
Get into the ex4 directory we provided you. The files in that directory are:
Change.java
ChangeTester.java
CashRegTester4.java (A tester program just for ex4)
Copy just your CashReg.java file from exercise 3 to ex4. You will not be using the tester from the previous exercises here (use CashRegTester4 instead).
In this exercise you are going to improve the cash register so it can tell the retail salesperson exactly how to give the change (i.e., how many dollars, quarters, dimes, etc.), not just how much the total is for the change to return. This will involve modifying the CashReg method giveChange. Read this section before jumping into that task: you should follow the steps below for more information about how to make this modification using a class we already wrote for you to help out.
In other programming languages there is a way to return multiple values back from a function by using reference parameters: Java does not have reference parameters (we will be talking more about this in lecture soon). So if you wanted to change the giveChange function so it gives us back various values, one way to do so would involve turning it into several functions that each returns one of the values: e.g., giveQuarters() would return how many quarters to give in change, and there would be a similar function for each of the other denominations.
Instead, here you’re going to keep giveChange as a single function, but return multiple values by packaging them into one object.
We wrote a class for you called Change to represent some amount of change (i.e., dollars, quarters, dimes, etc.) that might be in your pocket. (Note: its test program is called ChangeTester). You will be modifying the CashReg class so giveChange will return an object of type Change. Also, receivePayment will now take take a Change argument to simplify it (the old version took 5 parameters, one for each denomination of coin plus dollar bills.) The rest of this section goes into more detail on that new interface and steps for incorporating those changes.
You won’t have to modify CashRegTester4 to use the new interface to the CashReg class and otherwise make use of the Change class, because this version already does that for you (it has the same test cases as the old version).
Look at the new CashRegTester4.java to see how it has changed. In particular, look at the calls to receivePayment and giveChange and compare them with the old version.
To start the modifications to CashReg.java first just make a stub version of giveChange that returns a dummy Change value (one with all zeroes is a good option), and a stub for receivePayment with the correct interface. Since the receivePayment method doesn’t return a value, its stub will have an empty method body. The stub functions are:
public void receivePayment(Change money) {
// empty method body
}
public Change giveChange() {
return new Change(); // return 0 change object }
Compile and run this new version with the new test program. (This version, of course, will not get the correct results yet.) Save your results of this run into a file called ex4stub.out and take a look at them.

Now go ahead and modify giveChange so that it gives the correct change. When you have it working, save the output in a file called ex4.out. Since the output of this test program is somewhat different than in the other versions, you will not be able use diff to compare it with results for the other parts of the lab, but you should examine it to make sure it’s computing the results correctly.
Checkoff for DEN students
When you click the Submit button, it will be looking for and compiling (for source code) the files
README, ex1.out, CashRegTester.java (in your home directory),
and ex2/CashReg.java, ex2/ex2.out, ex3/CashReg.java, and ex3/ex3.out (in the subdirectories shown).