Project Requirements 
question 1 
In this project you need to write software for UIC's finance office. The finance office deals with the finances of different 
kinds of people at UIC: students who pay money for their tuitions, employees who receive money for their salaries, etc. 
All these people pay or receive a certain amount of money, expressed in yuans. 
Write a Payer interface for people who pay money to the finance office, with the following UML specification: 
+-------------------------------+ 
| <<interface>> | 
| Payer | 
+-------------------------------+ 
| + getName(): String | 
| + getDebt(): int | 
| + pay(int amount): void | 
+-------------------------------+ 
and a Person class that implements Payer and has the following UML specification: 
+------------------------------------+ 
| Person | 
+------------------------------------+ 
| - name: String | 
| - debt: int | 
+------------------------------------+ 
| + Person(String name, int debt) | 
| + getName(): String | 
| + getDebt(): int | 
| # setDebt(int debt): void | 
| + pay(int amount): void | 
| + testPerson(): void | 
+------------------------------------+ 
The name instance variable indicates the name of the Person. The debt instance variable indicates the amount of money 
that the person must pay to UIC (to simplify the assignment we will assume that money is always expressed as an integer 
number of yuans). 
The setDebt method changes the amount of debt that a person has. The setDebt method is protected, not 
public. This means that only subclasses of the Person class can use the setDebt method. All the other classes in the 
software cannot use the setDebt method, so they cannot change the amount of debt a person has, which is good for 
security. 
The purpose of the pay method is to decrease or increase the amount of debt a person has (depending on what kind of 
person it is) by the amount given as argument to the method. The pay method of the Person class is abstract, since 
we do not know what kind of person the person is (a person paying money or a person receiving money). question 2 
Add a class Student that extends Person. The constructor of the Student class takes as arguments a name and the 
amount of UIC debt that the student has (because the student needs to pay tuition or pay for the dormitory, for example). 
The Student class does not have any instance variable. 
The pay method of the Student class makes the student pay money to UIC, which decreases the amount of debt that 
the student has by the amount of money given as argument to the method. A student can have a negative debt (meaning 
that the student paid too much to UIC, which always makes UIC happy). 
question 3 
Add a class Employee that extends Person. The constructor of the Employee class takes as arguments the name of 
the employee and the salary that UIC must pay to the employee. If the salary given as argument is strictly less than zero 
then the constructor must throw a NegativeSalaryException with the message "An employee cannot have 
a negative salary!" The Employee class does not have any instance variable. 
Warning: the constructor of the Employee class takes as argument the salary of the employee (the amount of money 
that UIC must pay to the employee) but the debt instance variable of the Person class indicates how much money the 
person must pay to UIC. Therefore a positive salary is the same as a negative debt. 
The pay method of the Employee class makes UIC pay money to the employee, which decreases the current salary of 
the employee by the amount of money given as argument to the method (so the debt of the employee becomes less 
negative!) For example, if an employee currently has a salary of 10000 yuans (-10000 yuans of debt) and pay(2000) is 
called then the employee's salary becomes 8000 yuans (-8000 yuans of debt, meaning that UIC still needs to pay an extra 
8000 yuans to the employee after paying the 2000 yuans). It is fine for the pay method to be given a negative value as 
argument, which means the employee then just receives a salary increase. For example, if an employee currently has a 
salary of 10000 yuans and pay(-2000) is called then the employee's salary becomes 12000 yuans. An employee cannot 
be overpaid money by UIC though, so the current salary of the employee must always be positive or zero, never negative 
(the debt of the employee cannot be positive). If the argument given to the pay method is too positive and would change 
the employee's salary to become negative, then instead the current salary of the employee must not change and the pay 
method must throw a NegativeSalaryException with the message "An employee cannot be overpaid 
by XXX yuans!", where XXX is replaced with the amount of the overpayment. For example, if an employee currently 
has a salary of 10000 yuans and pay(12000) is called then the employee still has a salary of 10000 yuans and the 
method throws a NegativeSalaryException with the message "An employee cannot be overpaid by 
2000 yuans!" 
Note: to simplify the project, do not worry about the setDebt method. 
Change other classes and interfaces as necessary. 
question 4 
Add a class FacultyMember that extends Employee. The constructor of the FacultyMember class takes as 
arguments the name of the faculty member and the salary that UIC must pay to the faculty member. The 
FacultyMember class does not have any instance variable. 
The pay method of the FacultyMember class makes UIC pay money to the faculty member, which decreases the 
current salary of the faculty member by the amount of money given as argument to the method (so the debt of the faculty member becomes less negative!) In addition to the normal salary, a faculty member might also temporarily borrow extra 
money from UIC that the faculty member will need to reimburse later, so the salary of a faculty member might then 
become negative (the debt becomes positive) without throwing any exception: a negative salary (positive debt) then just 
means that the faculty member has temporarily borrowed some money. 
Change other classes and interfaces as necessary. 
question 5 
Add a FinanceOffice class with the following UML specification: 
+--------------------------------------------+ 
| FinanceOffice | 
+--------------------------------------------+ 
| - name: String | 
| - payers: ArrayList<Payer> | 
+--------------------------------------------+ 
| + FinanceOffice(String name) | 
| + addPayer(Payer payer): void | 
| + totalDebt(): int | 
| + getDebt(String name): int | 
| + pay(String name, int amount): void | 
| + testFinanceOffice(): void | 
+--------------------------------------------+ 
When a finance office is created, it has an arraylist of payers but the arraylist is empty (the arraylist does not contain any 
payer). 
The addPayer method takes a payer as argument and adds the payer to the arraylist of payers for the finance office. 
The totalDebt method returns as result the total amount of debt of all the payers of the finance office (if the result is 
positive then it means that the finance office will receive more money from all the students (and the faculty members 
with debts) than it needs money to pay all the salaries of the employees and UIC will then make a profit; if the result is 
negative then it means that the finance office will not get enough money from the students and will need to borrow extra 
money from a bank to be able to pay all the employees, otherwise UIC will go bankrupt; if the result is zero then it means 
that the money paid by all the students will exactly cover the salaries of the employees). 
The getDebt method takes as argument the name of a payer and returns as result the current amount of debt for this 
payer. If the finance office does not have a payer with the correct name then the getDebt method must throw an 
UnknownPayerException with the message "Payer XXX unknown", where XXX is replaced with the name of 
the payer. Do not worry about multiple payers having the same name. 
The pay method takes as argument the name of a payer and an amount of money and uses the pay method of that payer 
to pay that amount of money to that payer. If the finance office does not have a payer with the correct name then the 
pay method must throw an UnknownPayerException with the message "Payer XXX unknown", where XXX is 
replaced with the name of the payer. Do not worry about multiple payers having the same name. 
Note: the pay method does not catch any exception, it only throws exceptions. 
question 6 
In this question and the next one we want to create a command line interface (CLI) for our finance office software. Add a CLI class with a main method. Your code then has two classes with a main method: the Test class that you can 
use to run all your tests for all your classes, and the CLI class that you will now use to run the interactive text-based 
interface of your program. 
The CLI class does not have any testCLI method because this class is only used to allow users to use the software 
interactively. 
Add to the CLI class a private static input instance variable which is a Scanner object that reads input from the 
standard input stream System.in: 
 private static Scanner input = new Scanner(System.in); 
Always use this input scanner object when you need to read input. (Never close this scanner object, because this would 
also close the standard input stream System.in, and then the next time you tried to read something from the standard 
input stream you would get a NoSuchElementException!) 
In addition to the main method and the input instance variable, the CLI class has two methods called readLine and 
readPosInt. 
The readLine method is static and private, it takes a string as argument, and returns another string as result. The 
readPosInt method is static and private, it takes a string as argument, and returns a positive integer as result. 
The readLine method uses System.out.print (not println) to print its string argument on the screen (later 
when we use the readLine method, the string argument of the method will be a message telling the user to type some 
text). Then the readLine method uses the input scanner object to read a whole line of text from the user of the 
program and returns the text as result. 
The readPosInt method uses System.out.print (not println) to print its string argument on the screen (later 
when we use the readPosInt method, the string argument of the method will be a message telling the user to type some 
integer). Then the readPosInt method uses the input scanner object to read an integer from the user of the program. 
After reading the integer, the readPosInt method must also use the scanner's nextLine method to read the single 
newline character that comes from the user pressing the Enter key on the keyboard after typing the integer (if you do 
not read this newline character using the nextLine method inside the readPosInt method, then the newline 
character will remain in the input stream, and, the next time you use the readLine method described above, the 
readLine method will just immediately read only the newline character from the input stream and return an empty 
string as result, without waiting for the user to type anything!) 
If the user types something which is not an integer, then the nextInt method of the scanner will throw an 
InputMismatchException. In that case the code of your readPosInt method must catch the exception, use 
System.out.println to print the error message "You must type an integer!" to the user (use 
System.out.println for this, not System.err.println, otherwise you might hit a bug in Eclipse...), use the 
scanner's nextLine method to read (and ignore) the wrong input typed by the user of the program (if you do not do 
this, the wrong input typed by the user will remain in the input stream, and the next time you call the nextInt method 
again, you will get an InputMismatchException again!), and then do the whole thing again (including printing again 
the string argument of the readPosInt method) to try to read an integer again (hint: put the whole code of the method 
inside a while loop). 
After reading the integer and the newline character (which is just ignored), the readPosInt method tests the integer. 
If the integer is bigger than or equal to zero, then the readPosInt method returns the integer as result. If the integer is strictly less than zero, then the readPosInt method uses System.out.println to print the error message 
"Positive integers only!" to the user (use System.out.println for this, not System.err.println, 
otherwise you might hit a bug in Eclipse...), and then does the whole thing again (including printing again the string 
argument of the readPosInt method) to try to read an integer again (hint: just print the error message, and then the 
while loop you already have around the whole code will automatically do the whole thing again...) 
For example, if you want to check that your two methods readLine and readPosInt work correctly, put the following 
code in the main method of your CLI class: 
 public static void main(String[] args) { 
 String str1 = readLine("Type some text: "); 
 System.out.println("Text read is: " + str1); 
 int i = readPosInt("Type an integer: "); 
 System.out.println("Integer read is: " + i); 
 String str2 = readLine("Type some text again: "); 
 System.out.println("Text read is: " + str2); 
 } 
then running the main method of the CLI class should look like this (where aaaa bbbb, cccc, dddd eeee, -100, 
-200, 1234, and ffff gggg are inputs typed by the user on the keyboard): 
Type some text: aaaa bbbb 
Text read is: aaaa bbbb 
Type an integer: cccc 
You must type an integer! 
Type an integer: dddd eeee 
You must type an integer! 
Type an integer: -100 
Positive integers only! 
Type an integer: -200 
Positive integers only! 
Type an integer: 1234 
Integer read is: 1234 
Type some text again: ffff gggg 
Text read is: ffff gggg 
question 7 
Once you have checked that your methods readLine and readPosInt work correctly, remove all the code inside the 
main method of the CLI class so that the main method is empty again. 
In the rest of this question, use the readLine and readPosInt methods every time your program needs to read a 
string or an integer from the user. 
In the empty main method of the CLI class, create a single FinanceOffice object with the name "UIC FO". The 
main method of the CLI class must then print a menu that allows the user of your software to do six different actions 
that involve the finance office object, and your program must then read an integer from the user that indicates which 
action must be performed by the program (see below for the details of each action). Use the readPosInt method to 
print the menu (give the string for the menu as the argument of readPosInt) and to read the integer typed by the user. 
For example, the menu should look like this: 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 
The user then types an integer between 1 and 6 to select the action. For example (where 3 is an input from the user): 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
and your program then performs the selected action. 
After an action has been performed by your program, your program must again print the menu and ask again the user of 
the program for the next action to perform (hint: put the whole code of the main method inside a while loop, except 
for the one line of code that creates the single finance office object). 
If the user types an integer which is not between 1 and 6, then your program must print an error message "Unknown 
action!" to the user (hint: when testing the integer for the action, use the default case of a switch statement) 
and then print the menu again (by just going back to the beginning of the while loop). 
For example (where 7 is an input from the user): 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 7 
Unknown action! 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 
If the user types something which is not an integer, the readPosInt method that you implemented in the previous 
question will automatically repeat the menu and ask the user to type an integer again until the user actually types an 
integer, so you do not have to worry about this in the code of the main method of your CLI class. 
For example (where aaaa and bbbb cccc are inputs from the user): 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): aaaa 
You must type an integer! 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): bbbb cccc 
You must type an integer! 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 
Here are the detailed explanations for each action. 
Action 1: printing the total amount of debt. 
When the user of the software specifies action 1, your program must simply print on the screen the total amount of debt 
for all the payers of the finance office. Then your program goes back to printing the menu of actions (by just going back 
to the beginning of the while loop). 
For example (where 1 is an input from the user): 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 1 
Total amount of debt: 2000 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 
Action 2: adding a new payer to the finance office. 
When the user of the software specifies action 2, your program must add a new payer to the finance office. To add a new 
payer, your program needs to ask the user three things: the type of payer (an integer read using readPosInt: the integer 
1 represents a student, the integer 2 represents an employee, the integer 3 represents a faculty member, and any other 
integer must result in an error message "Unknown type of payer!" being printed and the software going 
immediately back to the main menu), the name of the payer (a string read using readLine), and the initial amount of 
money for the debt (for a student) or the salary (for an employee or a faculty member) when the payer is created. You 
program must then create the correct payer, add it to the finance office, and print an information message for the user of 
the software. The program then goes back to the menu. For example (where 1, 2, -100, 4, 2, 1, UIC Student, 5000, 1, 2, 2, Daniel, 1000, 1, 2, 3, Thompson, 2000, and 
1 are inputs from the user): 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 1 
Total amount of debt: 0 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 2 
Enter the payer type (student:1 employee:2 faculty member:3): -100 
Positive integers only! 
Enter the payer type (student:1 employee:2 faculty member:3): 4 
Unknown type of payer! 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 2 
Enter the payer type (student:1 employee:2 faculty member:3): 1 
Enter the name of the payer: UIC Student 
Enter the initial amount of money: 5000 
Student "UIC Student" with 5000 yuans of debt added 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 1 
Total amount of debt: 5000 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 2 
Enter the payer type (student:1 employee:2 faculty member:3): 2 
Enter the name of the payer: Daniel 
Enter the initial amount of money: 1000 
Employee "Daniel" with 1000 yuans of salary added 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 1 
Total amount of debt: 4000 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 2 
Enter the payer type (student:1 employee:2 faculty member:3): 3 
Enter the name of the payer: Thompson 
Enter the initial amount of money: 2000 
Faculty member "Thompson" with 2000 yuans of salary added 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 1 
Total amount of debt: 2000 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 
Note that the readPosInt method prevents the initial amount of money from being negative, so the constructor for 
the Employee class will never throw a NegativeSalaryException when you create an employee object. 
Nevertheless the code of the main method of your CLI class must handle this exception correctly by printing the error 
message "BUG! This must never happen!" and immediately terminating the program using System.exit(1). 
The same applies to a faculty member. 
Action 3: listing the amount of debt for a given payer. 
When the user of the software specifies action 3, your program must ask the user to type the name of a payer, and the 
program then prints the amount of debt for this payer. 
For example (where 3, UIC Student, 3, Daniel, 3, and Thompson are inputs from the user): 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: UIC Student 
UIC Student has 5000 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: Daniel 
Daniel has -1000 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: Thompson 
Thompson has -2000 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 
If the name of the payer is wrong (the finance office does not have a payer with this name) then an 
UnknownPayerException will be thrown by the FinanceOffice object. The code of the main method of your CLI class must then catch this exception, print the error message from the exception object, and then it just goes back to 
printing the menu of actions (by just going back to the beginning of the while loop). 
For example (where 3 and aaaa are inputs from the user): 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: aaaa 
Payer aaaa unknown 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 
Action 4: paying money to a given payer. 
When the user of the software specifies action 4, your program must ask the user to type the name of a payer and an 
amount of money, and the program then uses that amount of money to call the pay method of the payer with that name. 
Then the program goes back to the main menu. 
For example: 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: UIC Student 
UIC Student has 5000 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 4 
Enter the name of the payer: UIC Student 
Enter the amount of money: 1000 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: UIC Student 
UIC Student has 4000 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: Daniel 
Daniel has -1000 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 4 
Enter the name of the payer: Daniel 
Enter the amount of money: -500 
Positive integers only! 
Enter the amount of money: 500 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: Daniel 
Daniel has -500 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: Thompson 
Thompson has -2000 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 4 
Enter the name of the payer: Thompson 
Enter the amount of money: 500 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: Thompson 
Thompson has -1500 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 
If the name of the payer is wrong (the finance office does not have a payer with this name) then an 
UnknownPayerException will be thrown by the FinanceOffice object. The code of the main method of your 
CLI class must then catch this exception, print the error message from the exception object, and then it just goes back to 
printing the menu of actions (by just going back to the beginning of the while loop). 
For example: 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 4 
Enter the name of the payer: aaaa 
Enter the amount of money: 1000 
Payer aaaa unknown Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 
If a payer is an employee and the amount of money typed by the user is too big then a NegativeSalaryException 
will be thrown by the Employee object. The code of the main method of your CLI class must then catch this exception, 
print the error message from the exception object, and then it just goes back to printing the menu of actions (by just going 
back to the beginning of the while loop). 
For example: 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: Daniel 
Daniel has -500 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 4 
Enter the name of the payer: Daniel 
Enter the amount of money: 1500 
An employee cannot be overpaid by 1000 yuans! 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: Daniel 
Daniel has -500 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: UIC Student 
UIC Student has 4000 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 4 
Enter the name of the payer: UIC Student 
Enter the amount of money: 5000 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: UIC Student 
UIC Student has -1000 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: Thompson 
Thompson has -1500 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 4 
Enter the name of the payer: Thompson 
Enter the amount of money: 2000 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: Thompson 
Thompson has 500 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 
Action 5: taking money from a given payer. 
When the user of the software specifies action 5, your program must ask the user to type the name of a payer and an 
amount of money, and the program then uses that amount of money, makes it negative, and pays that negative amount 
to the payer with that name. Then the program goes back to the main menu. 
For example: 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: UIC Student 
UIC Student has 4000 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 5 
Enter the name of the payer: UIC Student 
Enter the amount of money: 1000 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: UIC Student 
UIC Student has 5000 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: Daniel 
Daniel has -500 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 5 
Enter the name of the payer: Daniel Enter the amount of money: -500 
Positive integers only! 
Enter the amount of money: 500 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: Daniel 
Daniel has -1000 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: Thompson 
Thompson has -1500 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 5 
Enter the name of the payer: Thompson 
Enter the amount of money: 500 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: Thompson 
Thompson has -2000 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 
If the name of the payer is wrong (the finance office does not have a payer with this name) then an 
UnknownPayerException will be thrown by the FinanceOffice object. The code of the main method of your 
CLI class must then catch this exception, print the error message from the exception object, and then it just goes back to 
printing the menu of actions (by just going back to the beginning of the while loop). 
For example: 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 5 
Enter the name of the payer: aaaa 
Enter the amount of money: 1000 
Payer aaaa unknown 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 
Note that, even if a payer is an employee, the readPosInt method prevents the amount of money typed by the user 
from being negative. This means an employee will never throw a NegativeSalaryException. Nevertheless the code 
of the main method of your CLI class must handle this exception by printing the error message "BUG! This must 
never happen!" and immediately terminating the program using System.exit(1). 
Action 6: quitting the program. 
When the user of the software specifies action 6, your program must print a "Goodbye!" message, and terminate the 
program using: System.exit(0). 
For example (where 6 is an input from the user): 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 6 
Goodbye! 
Here is a more complete example of running the software: 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): aaaa 
You must type an integer! 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): bbbb cccc 
You must type an integer! 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): -100 
Positive integers only! 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 7 
Unknown action! 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 1 
Total amount of debt: 0 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 2 
Enter the payer type (student:1 employee:2 faculty member:3): -100 
Positive integers only! Enter the payer type (student:1 employee:2 faculty member:3): 4 
Unknown type of payer! 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 2 
Enter the payer type (student:1 employee:2 faculty member:3): 1 
Enter the name of the payer: UIC Student 
Enter the initial amount of money: 5000 
Student "UIC Student" with 5000 yuans of debt added 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 1 
Total amount of debt: 5000 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 2 
Enter the payer type (student:1 employee:2 faculty member:3): 2 
Enter the name of the payer: Daniel 
Enter the initial amount of money: 1000 
Employee "Daniel" with 1000 yuans of salary added 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 1 
Total amount of debt: 4000 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 2 
Enter the payer type (student:1 employee:2 faculty member:3): 3 
Enter the name of the payer: Thompson 
Enter the initial amount of money: 2000 
Faculty member "Thompson" with 2000 yuans of salary added 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 1 
Total amount of debt: 2000 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: UIC Student 
UIC Student has 5000 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: Daniel 
Daniel has -1000 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: Thompson 
Thompson has -2000 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: aaaa 
Payer aaaa unknown 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 4 
Enter the name of the payer: UIC Student 
Enter the amount of money: 1000 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: UIC Student 
UIC Student has 4000 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 4 
Enter the name of the payer: Daniel 
Enter the amount of money: -1000 
Positive integers only! 
Enter the amount of money: 1000 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: Daniel 
Daniel has 0 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 4 
Enter the name of the payer: Thompson 
Enter the amount of money: 500 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: Thompson 
Thompson has -1500 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 1 
Total amount of debt: 2500 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 4 
Enter the name of the payer: aaaa 
Enter the amount of money: 1000 
Payer aaaa unknown 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 5 
Enter the name of the payer: UIC Student Enter the amount of money: 1000 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: UIC Student 
UIC Student has 5000 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 5 
Enter the name of the payer: Daniel 
Enter the amount of money: -1000 
Positive integers only! 
Enter the amount of money: 1000 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: Daniel 
Daniel has -1000 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 5 
Enter the name of the payer: Thompson 
Enter the amount of money: 500 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: Thompson 
Thompson has -2000 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 1 
Total amount of debt: 2000 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 5 
Enter the name of the payer: aaaa 
Enter the amount of money: 1000 
Payer aaaa unknown 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 4 
Enter the name of the payer: UIC Student 
Enter the amount of money: 6000 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: UIC Student 
UIC Student has -1000 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 4 
Enter the name of the payer: Daniel 
Enter the amount of money: 1500 
An employee cannot be overpaid by 500 yuans! 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: Daniel 
Daniel has -1000 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 4 
Enter the name of the payer: Thompson 
Enter the amount of money: 2500 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 3 
Enter the name of the payer: Thompson 
Thompson has 500 yuans of debt 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 1 
Total amount of debt: -1500 
Type an action (total:1 add:2 get:3 give:4 take:5 quit:6): 6 
Goodbye! 
question 8 
We now want to create a graphical user interface (GUI) for our finance office software. Since we want our finance office 
software to have multiple views, we will use the Model-View-Controller design pattern. 
First, create a ModelListener interface with the following UML specification: 
+-------------------+ 
| <<interface>> | 
| ModelListener | 
+-------------------+ 
| + update(): void | 
+-------------------+ This interface will be implemented by views and the model will use this interface to notify the views that they need to 
update themselves. 
Second, the FinanceOffice class is the class that contains all the data for the finance office. Therefore the 
FinanceOffice class plays the role of the model. Therefore the FinanceOffice class needs to have an arraylist of 
model listeners that needs to be notified every time the finance office (the model) changes. Therefore add to the 
FinanceOffice class an arraylist of ModelListener. Also add to the FinanceOffice class an addListener 
method that takes a ModelListener as argument and adds it to the arraylist of listeners. Also add to the 
FinanceOffice class a private notifyListeners method that takes nothing as argument and calls the update 
method of all the listeners of the finance office. Then change the addPayer and pay methods so that they call the 
notifyListeners every time a change is made to the finance office's data (only the addPayer and pay methods 
change the finance office's data, so only these two methods need to call the notifyListeners method; the 
totalDebt and getDebt methods do not change the finance office's data, they only inspect the data, so they do not 
need to call the notifyListeners method). 
Use the Test class to make sure all your tests still work. Use the CLI class to make sure your command line interface still 
works. 
Third, create a ViewSimple class that extends JFrame, implements the ModelListener interface, and has the 
following UML specification: 
+--------------------------------------------------------+ 
| ViewSimple | 
+--------------------------------------------------------+ 
| - m: FinanceOffice | 
| - c: ControllerSimple | 
| - label: JLabel | 
+--------------------------------------------------------+ 
| + ViewSimple(FinanceOffice m, ControllerSimple c) | 
| + update(): void | 
+--------------------------------------------------------+ 
The constructor of the ViewSimple class registers the view with the model (the finance office) using the addListener 
method of the model, creates a JLabel object, stores it in the label instance variable of the ViewSimple class, 
initializes the label to display the total amount of debt of all the payers of the finance office, and adds the label to the view 
(which is a frame). The update method of the ViewSimple class updates the text of the label as necessary so that 
the label always displays the current total amount of debt of all the payers of the finance office. 
Fourth, create a ControllerSimple class with the following UML specification: 
+------------------------------------------+ 
| ControllerSimple | 
+------------------------------------------+ 
| - m: FinanceOffice | 
+------------------------------------------+ 
| + ControllerSimple(FinanceOffice m) | +------------------------------------------+ 
Since the ViewSimple does not have any button, it cannot perform any action, therefore the corresponding controller 
ControllerSimple does nothing. (We still want to have the ControllerSimple class so that our application 
follows the correct Model-View-Controller design pattern.) 
Fifth, create a GUI class with a main method. In this main method, create an anonymous class that implements the 
Runnable interface with a run method and use the javax.swing.SwingUtilities.invokeLater method to 
run that code on the event dispatch thread. 
Sixth, we need to connect the model, the view, and the controller to each other. So in the run method of the anonymous 
class: 
• create a FinanceOffice object (the model object) with the name "UIC FO"; 
• then create a ControllerSimple object (the controller object) that takes the model object as argument; 
• then create a ViewSimple object that takes the model object and the controller object as arguments. 
Use the GUI class to run your GUI: you should see a window that shows the total amount of debt of all the payers of the 
finance office. This total amount must be zero, since the finance office (model object) you just created above does not 
have any payer! 
As a test, in the run method of the anonymous class, you can try to manually add to your finance office (model object) 
some students, employees, and faculty members to check that your GUI displays the correct total amount of debt for all 
the payers of the finance office. For example: 
 
question 9 
In the next questions we want to add more views. So, to simplify the next questions, create a View class which is going 
to be the superclass of all views. This View class is generic, extends JFrame, implements the ModelListener 
interface, and has the following UML specification: 
+------------------------------------------+ 
| View<T extends Controller> | 
+------------------------------------------+ 
| # m: FinanceOffice | 
| # c: T | 
+------------------------------------------+ 
| + View(FinanceOffice m, T c) | 
| + update(): void | 
+------------------------------------------+ 
The m and c instance variables of the View class are protected (so that they can be easily used in all the subclasses of 
View). In the constructor of the View class, the view registers itself with the model. The update method of the View 
class is abstract. Then modify the ViewSimple class to be a subclass of the View<…> class. The ViewSimple class must then have only 
one instance variable: the label. To simplify a little the code of the next questions, also move the 
setDefaultCloseOperation method call from the constructor of ViewSimple to the constructor of View. Also 
make sure that the ViewSimple does not directly register itself with the model anymore, since this is now done in the 
superclass View. 
Also create a Controller class which is going to be the superclass of all controllers. This Controller class has the 
following UML specification: 
+------------------------------------------+ 
| Controller | 
+------------------------------------------+ 
| # m: FinanceOffice | 
+------------------------------------------+ 
| + Controller(FinanceOffice m) | 
+------------------------------------------+ 
The m instance variable of the Controller class is protected (so that it can be easily used in all the subclasses of 
Controller). 
Then modify the ControllerSimple class to be a subclass of the Controller class. (Note: since 
ControllerSimple does nothing anyway, we could just remove it and replace it with Controller in the definition 
of ViewSimple and in the run method of the GUI class, but here we keep ControllerSimple just to make the 
Model-View-Controller design pattern very clear.) 
Run your GUI and check that it still works as before. 
question 10 
We now want to add a new “get debt” view that allows the user of the software to check how much debt a specific payer 
has. 
Create a ViewGetDebt class that extends View<ControllerGetDebt> and has the following UML specification: 
+------------------------------------------------------------+ 
| ViewGetDebt | 
+------------------------------------------------------------+ 
| - t: JTextField | 
+------------------------------------------------------------+ 
| + ViewGetDebt(FinanceOffice m, ControllerGetDebt c) | 
| + update(): void | 
+------------------------------------------------------------+ 
The ViewGetDebt shows the text field called t (where the user can type text) and a button. Use a grid layout manager 
to position the two components. For example: 
 The user can type in the text field t the name of a payer. For example: 
 
When the user then clicks on the button, the action listener of the button must read the name of the payer that was typed 
in the text field (using the getText method of the text field) and must call the getDebt method of the controller with 
that payer name as argument. The getDebt method of the controller returns a string as result which must then be 
displayed back to the user using a message dialog (using the showMessageDialog method of the JOptionPane 
class). For example: 
 
The update method of the ViewGetDebt class does nothing, because the ViewGetDebt class does not graphically 
display any data from the finance office (the model). 
Also create a ControllerGetDebt class that extends Controller and has the following UML specification: 
+--------------------------------------------+ 
| ControllerGetDebt | 
+--------------------------------------------+ 
+--------------------------------------------+ 
| + ControllerGetDebt(FinanceOffice m) | 
| + getDebt(String name): String | 
+--------------------------------------------+ 
The getDebt method takes the name of a payer as argument. The getDebt method of the controller then calls the 
getDebt method of the finance office to get the current amount of debt of that payer. The getDebt method of the 
controller then transforms the integer result of the getDebt method of the finance office into a string and returns that 
string as result (to the view). If the getDebt method of the finance office throws an UnknownPayerException then 
the getDebt method of the controller must catch this exception and return as result the error message from the 
exception object. 
Modify the run method of the GUI class to add a ViewGetDebt view that uses a ControllerGetDebt controller 
and the same model as before (not a new model!) Do not delete the previous view. 
Run your GUI and check that you can correctly use the new view to query the amount of debt of different payers of your 
finance office (obviously your finance office must have some payers to test this: see the last paragraph of question 8). 
Also check that querying the amount of debt of an unknown payer correctly shows an error message. For example:  
question 11 
We now want to add a new “pay money” view that allows the user of the software to pay money to a specific payer. 
Create a ViewPay class that extends View<ControllerPay> and has the following UML specification: 
+--------------------------------------------------------------+ 
| ViewPay | 
+--------------------------------------------------------------+ 
| - t1: JTextField | 
| - t2: JTextField | 
+--------------------------------------------------------------+ 
| + ViewPay(FinanceOffice m, ControllerPay c) | 
| + update(): void | 
+--------------------------------------------------------------+ 
The ViewPay shows the two text field called t1 and t2 (where the user can type text) and a button. Use a grid layout 
manager to position the three components. For example: 
 
The user can type in the first text field the name of a payer and can type in the second text field an amount of money. For 
example: 
 
When the user then clicks on the button, the action listener of the button must read the name of the payer that was typed 
in the first text field (using the getText method of the text field) and the amount of money that was typed in the second 
text field (using again the getText method) and must call the pay method of the controller with these two strings as 
arguments. The pay method of the controller then returns a string as result. If the string returned by the pay method of 
the controller is different from the empty string "" then this string must be displayed back to the user using a message dialog (using the showMessageDialog method of the JOptionPane class). If the string returned by the pay method 
of the controller is equal to the empty string "" then nothing happens in ViewPay. 
The update method of the ViewPay class does nothing, because the ViewPay class does not graphically display any 
data from the finance office (the model). 
Also create a ControllerPay class that extends Controller and has the following UML specification: 
+-------------------------------------------------+ 
| ControllerPay | 
+-------------------------------------------------+ 
+-------------------------------------------------+ 
| + ControllerPay(FinanceOffice m) | 
| + pay(String name, String amount): String | 
+-------------------------------------------------+ 
The pay method takes the name of a payer and an amount of money (as a string) as arguments. The pay method of the 
controller then transforms the amount of money from a string to an integer (using the Integer.parseInt static 
method) and calls the pay method of the finance office to pay the amount of money to the payer with the correct name. 
• If no exception occurs then the pay method of the controller returns the empty string. 
• If the pay method of the finance office throws an UnknownPayerException then the pay method of the 
controller must catch this exception and return as result the error message from the exception object. 
• If the pay method of the finance office throws a NegativeSalaryException then the pay method of the 
controller must catch this exception and return as result the error message from the exception object. 
• If the parseInt method of the Integer class throws a NumberFormatException (because the user typed 
something which is not an integer) then the pay method of the controller must catch this exception and return as 
result the error message from the exception object. 
Note: to keep things simple, it is allowed for a user of your software to type a negative amount of money in this “pay 
money” view, so there is no need to check for that in the controller. 
Modify the run method of the GUI class to add a ViewPay view that uses a ControllerPay controller and the same 
model as before (not a new model!) Do not delete the previous views. 
Run your GUI and check that you can correctly use the new view to pay money to different payers of your finance office 
(obviously your finance office must have some payers in it to test this: see the last paragraph of question 8). 
• Check that, when you pay money to a payer, the simple view is automatically correctly updated to show the new total 
amount of debt for all the payers of the finance office. 
• Also use the “get debt” view to check that the payer's debt correctly changed. 
• Also check that paying money to an unknown payer correctly shows an error message. For example: 
 • Also check that paying a large positive amount of money to an employee correctly shows an error message. For 
example: 
 
• Also check that trying to pay money to a payer by an amount which is not an integer correctly shows an error message 
(do not worry about the content of the error message). For example: 
 
question 12 
We now want to add a new “create” view that allows the user of the software to create a new payer for the finance office. 
Create a ViewCreate class that extends View<ControllerCreate> and has the following UML specification: 
+--------------------------------------------------------+ 
| ViewCreate | 
+--------------------------------------------------------+ 
| - t1: JTextField | 
| - t2: JTextField | 
| - cb: JComboBox<String> | 
+--------------------------------------------------------+ 
| + ViewCreate(FinanceOffice m, ControllerCreate c) | 
| + update(): void | 
+--------------------------------------------------------+ 
The ViewCreate shows the two text field called t1 and t2 (where the user can type text), the combo box cb (where 
the user can select one option from a menu) and a button. Use a grid layout manager to position the four components. 
For example: 
 The user can type in the first text field the name of a new payer and can type in the second text field an amount of money 
for the new payer. The combo box offers three menu options: "Student", "Employee", and "Faculty Member". 
For example: 
 
When the user then clicks on the button, the action listener of the button must read the name of the new payer that was 
typed in the first text field (using the getText method of the text field), read the amount of money that was typed in 
the second text field (using again the getText method), and read which menu option was selected in the combo box 
(using the getSelectedIndex method of the combo box, which returns the integer 0 or 1 or 2 depending on which 
menu option the user selected in the combo box), and calls the create method of the controller with these two strings 
and the integer as arguments. The create method of the controller then returns a string as result. If the string returned 
by the create method of the controller is different from the empty string "" then this string must be displayed back to 
the user using a message dialog (using the showMessageDialog method of the JOptionPane class). If the string 
returned by the create method of the controller is equal to the empty string "" then nothing happens in ViewCreate. 
The update method of the ViewCreate class does nothing, because the ViewCreate class does not graphically 
display any data from the finance office (the model). 
Also create a ControllerCreate class that extends Controller and has the following UML specification: 
+----------------------------------------------------------+ 
| ControllerCreate | 
+----------------------------------------------------------+ 
+----------------------------------------------------------+ 
| + ControllerCreate(FinanceOffice m) | 
| + create(String name, String amount, int type): String | 
+----------------------------------------------------------+ 
The create method takes as arguments the name of a new payer, an amount of money (as a string), and an integer 
representing the type of payer to create (where the integer 0 means a student, the integer 1 means a employee, and the 
integer 2 means a faculty member). The create method of the controller then transforms the amount of money from a 
string to an integer (using the Integer.parseInt static method), creates an object from the correct class (based on 
the type of payer specified by the user: student, or employee, or faculty member), and calls the addPayer method of 
the finance office to add the new payer object to the finance office. 
• If no exception occurs then the create method of the controller returns the empty string. 
• If the constructor of the Employee class throws a NegativeSalaryException then the create method of 
the controller must catch this exception and return as result the error message from the exception object. 
• If the parseInt method of the Integer class throws a NumberFormatException (because the user typed 
something which is not an integer) then the create method of the controller must catch this exception and return 
as result the error message from the exception object. Modify the run method of the GUI class to add a ViewCreate view that uses a ControllerCreate controller and 
the same model as before (not a new model!) Do not delete the previous views. 
Note: if at the end of question 8 you had manually added to your finance office (model object) some payers for testing, 
then you must now remove those payers from the run method of the anonymous class inside the GUI class. You do not 
need these test payers anymore because you have now a graphical user interface to create new payers! 
Run your GUI and check that you can correctly use the new view to create different payers for your finance office, with 
different types of payers. 
• Check that, when you create a new payer, the simple view is automatically correctly updated to show the new total 
amount of debt for all the payers of the finance office. 
• Also use the “get money” view to check that the payers are correctly created with the correct names and correct 
amounts of money. 
• Also check that trying to create an employee with a negative salary correctly shows an error message. For example: 
 
• Also check that trying to create a payer with an amount of money which is not an integer correctly shows an error 
message (do not worry about the content of the error message). For example: 
 
• After you have created a new payer, you can also check whether the new payer is an employee or not by using the 
“pay money” view to pay a large positive amount of money to the payer: 
o if the new payer you created is a student or a faculty member then paying a large positive amount of money will 
work and the amount of debt of the payer will change correctly (you can then check that using the “get debt” 
window); 
o if the new payer you created is an employee then paying a large positive amount of money will fail with an error 
message and the amount of debt of the employee will not change (you can then check that using the “get debt” 
window). 
question 13 
We now want to add a new “history” view that allows the user of the software to keep track of how the total amount of 
debt of all the payers of the finance office changes over time. 
Before we can add such a view to the GUI, first we need to change the model (the FinanceOffice class) to keep track 
of how the total amount of debt of all the payers of the finance office changes over time. Therefore, in the FinanceOffice class, add a new private instance variable called history which is an arraylist of integers. This 
arraylist must be initialized to contain only one value: zero (meaning that, when the finance office is created, its total 
amount of debt is zero). 
We know that the data of the finance office can change only in two methods of the FinanceOffice class: in the 
addPayer method and in the pay method (this is why these two methods both call notifyListeners: to tell the 
views that data has changed and that the views must update themselves). Therefore it is in these two methods addPayer 
and pay that we must keep track of how the total amount of debt of all the payers of the finance office changes over 
time. Therefore, in these two methods addPayer and pay, call the totalDebt method and add the result to the 
history arraylist. 
Note: in each of the two methods addPayer and pay, you must call the totalDebt method and add the result to 
the history arraylist before calling notifyListeners, otherwise the “history” view that you are going to create 
below will not show the correct results when it is notified by the finance office that it must update itself! 
Also add to the FinanceOffice class a getHistory method that returns as result the arraylist of integers which is 
the finance office's history. 
Create a HistoryPanel class that extends JPanel. The constructor of HistoryPanel takes as argument a model 
object of type FinanceOffice, which you need to store in some private instance variable. Add to the HistoryPanel 
class two private methods called historyMax and historyMin that take an arraylist of integers as argument and 
return as result the maximum and minimum number in the arraylist, respectively (you can assume that the arraylist 
contains at least one number). Then add to the HistoryPanel class a private method called historyRange that 
takes an arraylist of integers as argument and returns as result the difference between the max and min of the integers in 
the arraylist, or returns as result 200 if the difference between the man and min of the integers in the arraylist is strictly 
less than 200. 
Override the protected void paintComponent(Graphics g) method inherited from JPanel, and, inside 
your new paintComponent method, draw graphically how the total amount of debt of all the payers of the finance 
office changes over time, as follows: 
• Compute the following variables (where history is the result of calling the getHistory method of the model): 
 int min = historyMin(history); 
 int range = historyRange(history); 
 int maxX = getWidth() - 1; 
 int maxY = getHeight() - 1; 
 int zero = maxY + min * maxY / range; 
• Draw a blue line between the point (0, zero) and the point (maxX, zero) (this blue line then represents the 
horizontal “zero” axis). 
• For each value v at index i in the history arraylist that you want to draw: 
o Use x = 10 * i for the horizontal coordinate; 
o Use y = zero - v * maxY / range for the vertical coordinate; 
o Draw red lines between all the points (x, y) (if there is only one value in the arraylist then just draw a red 
rectangle of size 1 by 1 at position (x, y)). 
Create a ViewHistory class that extends View<ControllerHistory> and has the following UML specification: 
+----------------------------------------------------------+ 
| ViewHistory | 
+----------------------------------------------------------+ +----------------------------------------------------------+ 
| + ViewHistory(FinanceOffice m, ControllerHistory c) | 
| + update(): void | 
+----------------------------------------------------------+ 
The ViewHistory shows only a HistoryPanel object, nothing else. The update method of the ViewHistory 
class calls Swing's repaint method (this forces Swing to redraw everything every time the model changes, which in turn 
forces Swing to automatically call the paintComponent method of the HistoryPanel to redraw the updated version 
of the finance office's history). 
Also create a ControllerHistory class that extends Controller and has the following UML specification: 
+----------------------------------------------------------+ 
| ControllerHistory | 
+----------------------------------------------------------+ 
+----------------------------------------------------------+ 
| + ControllerHistory(FinanceOffice m) | 
+----------------------------------------------------------+ 
Since the ViewHistory does not receive any input from the user, the ControllerHistory does nothing. (Note: 
since ControllerHistory does nothing anyway, we could just remove it and replace it with Controller in the 
definition of ViewHistory and in the run method of the GUI class, but here we keep ControllerHistory just to 
make the Model-View-Controller design pattern very clear.) 
Modify the run method of the GUI class to add a ViewHistory view that uses a ControllerHistory controller 
and the same model as before (not a new model!) Do not delete the previous views. 
Run your GUI and check that adding new payers and paying money to payers correctly updates the graphical history of 
the total amount of debt for all the payers of the finance office. For example, if the user of the software creates a student 
with 2000 yuans of debt, then creates an employee with a salary of 2500 yuans, then creates a faculty member with a 
salary of 500 yuans, then pays 2000 yuans to the faculty member, then the graphical history of the finance office's total 
amount of debt must look like this (the last value is 1000 because it is the 2000 yuans of debt of the student, minus the 
2500 yuans of the salary of the employee, minus the 500 yuans of salary of the faculty member, plus the 2000 yuans paid 
to the faculty member): 
 
Check that all the other features of your software still work correctly. Also run your tests and the CLI to make sure 
everything still works correctly. 
question 14 
We now want to store the finance office's information (all the payers and the history, but not the finance office's name 
and not the finance office's listeners) into a binary file using object serialization. Add to the FinanceOffice class a new private file instance variable. In the constructor, initialize the file instance 
variable to be a File object for a binary file named "XXX.bin" (where XXX is replaced with the name of the finance 
office). Add to the FinanceOffice class a new public method called saveData that takes no argument, returns 
nothing, and uses object serialization to save into the binary file the payers and history arraylists of the finance office. 
Modify the constructor of the FinanceOffice class to read all the information from this binary file, if it exists, and put 
it into the corresponding arraylists (if the binary file does not exist then the arraylists must be initialized as before). 
Make other classes implement Java's Serializable interface as appropriate. 
Add to the Controller superclass a protected shutdown method that: 
• calls the saveData method of the model; 
• manually terminates the program using System.exit(0). 
Then modify the View superclass to: 
• hide the frame when the user clicks on the "close" button; 
• add a "window closing" event handler (use an anonymous window adapter) that calls the controller's shutdown 
method. 
Run your GUI, add some payers, make some changes to the debt or salary of some payers, exit the software, run the GUI 
again, and check that all the payers and history information is still there and is correct. Also check that the binary file is 
correctly created inside the folder for your Eclipse project (it is a binary file though, so you cannot read its content). 
Note that the command line interface that you created in question 7 reads all the information saved into the binary file 
when you start the command line interface (because the constructor of the FinanceOffice class will automatically 
read the content of the binary file if it exists and has the correct name) but it does not write the information back into the 
binary file when you quit the command line. This is easy to fix: in the main method of the CLI class, just before printing 
the "Goodbye!" message, call the saveData method of the FinanceOffice object that you created at the start of 
the main method. 
Run the command line interface and check that any change you make to the finance office's information using the 
command line interface is correctly saved into the binary file when you quit the command line interface. You can run the 
GUI to check this (but do not run the GUI and the CLI at the same time!) 
Use the Test class to run all the tests for the software and check that all the tests still work (delete the binary file before 
you do this, otherwise the FinanceOffice constructor that you use in your tests will read the payer data from the 
binary file, which will change the results of some of your tests). 
Here are a few extra instructions: 
• You should strictly follow the UML conventions when naming your class methods and class variables, otherwise, 
inconsistent naming conventions will lead to compilation failures when grading. 
• Give meaningful names to your variables so we can easily know what each variable is used for in your program. 
• Put comments in your code (in English!) to explain WHAT your code is doing and also to explain HOW your 
program is doing it. 
• Make sure all your code is properly indented (formatted). Your code should be beautiful to read. 
• In the stage of our study, packages are mutually independent, you're NOT allowed to call the class out of the 
current package. Let's take the example of Lab 4, and see the picture following.  
Failure to follow these instructions will result in you losing points.
 
请加QQ：99515681  邮箱：99515681@qq.com   WX：codinghelp