Project Requirements
Create a new Eclipse workspace named “Project_1234567890” on the desktop of your computer (replace 1234567890 with your student ID number). For each question below, create a new project in that workspace. Call each project by its question number: “Question1”, “Question2”, etc. If you do not remember how to create a workspace or projects, read the “Introduction to Eclipse” document which is on iSpace. Answer all the questions below. At the end of the project, create a ZIP archive of the whole workspace folder. The resulting ZIP file must be called “Project_1234567890.zip” (replace 1234567890 with your student ID number). Upload the ZIP file on iSpace.
Here are a few extra instructions:
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. Also put comments in your tests.
Make sure all your code is properly indented (formatted). Your code should be beautiful to read.
Failure to follow these instructions will result in you losing points.
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:
+——————————-+
| <
| 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).
Also add to your program a Test class to test your Person class.
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).
Make sure you test all the methods of your new Student class, including inherited methods.
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
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 Total amount of debt: 2000
Type an action (total:1 add:2 get:3 give:4 take:5
Action 2: adding a new payer to the finance office.
quit:6): 1
quit:6):
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, Philippe, 1000, 1, 2, 3, Meunier, 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: Philippe
Enter the initial amount of money: 1000
Employee “Philippe” 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: Meunier
Enter the initial amount of money: 2000
Faculty member “Meunier” 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, Philippe, 3, and Meunier 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: Philippe
Philippe 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: Meunier
Meunier 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: Philippe
Philippe 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: Philippe
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: Philippe
Philippe 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: Meunier
Meunier 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: Meunier
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: Meunier
Meunier 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
Enter the name of the payer: Philippe
Philippe has -500 yuans of debt
Type an action (total:1 add:2 get:3 give:4
Enter the name of the payer: Philippe
Enter the amount of money: 1500
take:5 quit:6): 3
take:5 quit:6): 4
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: Philippe
Philippe 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: Meunier
Meunier 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: Meunier
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: Meunier
Meunier 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: Philippe
Philippe 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: Philippe
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: Philippe
Philippe 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: Meunier
Meunier 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: Meunier
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: Meunier
Meunier 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
Positive integers only!
Type an action (total:1
Unknown action!
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: Philippe
Enter the initial amount of money: 1000
Employee “Philippe” 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: Meunier
Enter the initial amount of money: 2000
Faculty member “Meunier” 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: Philippe
Philippe 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: Meunier
Meunier 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
add:2 get:3 give:4 take:5 quit:6): -100
add:2 get:3 give:4 take:5 quit:6): 7
add:2 get:3 give:4 take:5 quit:6): 1
Type an action (total:1
Total amount of debt: 0
Type an action (total:1
Enter the payer type (student:1 employee:2 faculty member:3): -100 Positive integers only!
add:2 get:3 give:4 take:5 quit:6): 2
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: Philippe
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: Philippe
Philippe 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: Meunier
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: Meunier
Meunier 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: Philippe
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: Philippe
Philippe 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: Meunier
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: Meunier
Meunier 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: Philippe
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: Philippe
Philippe 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: Meunier
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: Meunier
Meunier 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:
+——————-+
| <
| 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
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
+————————————————————+ | 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
+————————————————————–+ | 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
+——————————————————–+
| ViewCreate | +——————————————————–+ | – t1: JTextField | | – t2: JTextField | | – cb: JComboBox
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
+———————————————————-+ | 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.
The end. That was fun!