Reference no: EM133693221

Agile Coding

Assessment task:

You will work by yourself to develop a Java program consisting of several classes, to demonstrate your understanding of topics from weeks 1 to 11, with a greater focus placed on topics from week 5 onwards.

You are provided a detailed set of functional requirements which describe the behaviour that must be exhibited or supported by the program you create. In addition to the various functional requirements are a few other requirements that specify suggested implementation approach to be taken and other things to be mindful of as you work through the assignment. All these requirements are all detailed in the remainder of the assignment. Make sure you read it all carefully before you commence, so that you understand what needs to be achieved. Finally, there are a range of suggested Tasks to be completed (see next page).

You can and should commence work early as coding takes time to get right and leaving it to a few days before the due date will only put yourself under stress. There are parts which you should already be able to work on as you would have already covered their topics in the classes that have occurred by now - only a few small things require topics of the later weeks.

If you have any questions about any of the requirements, please ask your teacher through their preferred means of communication.
This is an individual assignment. The work you submit must be written only by you and no-one else, and no AI code generator may be used - We are trying to assess you rather than AI. The code you submit will also be compared to work that other students submit, by using a specialised plagiarism- checking software that specifically compares Java programs, to identify any potential collusion or sharing of work between people.
You may also be asked to attend an interview with the marker to explain portions of the code or approaches you have taken, or to make small alterations to the code ‘live', before the assessment mark is finalised - if you do not participate in such interview when requested, you will receive no more than 50% of the available marks for the assignment.

Learning Outcome 1: Select and justify appropriate data types to represent information in a program. S2. Develop object-oriented programs involving several interacting classes.
Learning Outcome 2: Develop, compile, test and debug code using an appropriate IDE
Learning Outcome 3: Incorporate pre-written classes, including those from an API, into software solutions S5. Manage code assets through use of a source-code version control system repository.
Learning Outcome 4: Develop object-oriented programs which incorporate event driven aspects. S7. Analyse and explain the behaviour of code which someone else has written
Learning Outcome 5: Design, develop, test and debug programs from supplied program specifications. A2. Use source-code version control tools to manage a repository of code.
Learning Outcome 6: Explain the object-oriented principles of inheritance, polymorphism, encapsulation, dynamic binding and abstraction.
Learning Outcome 7: Explain the principles of event-driven programming as it applies to the development of graphical user interfaces

Assessment Details - Overview
Following on from the theme of Assignment 1, you are now to develop a program that could be used by a construction company to calculate the costs and time required for a construction company to build houses or industrial premises.

Tasks to be completed
The following is a description of the tasks you may want to complete to address the needs of this assignment:
Read through the entire assignment task description (all 14 pages) to understand what the program needs to achieve, and how you will be assessed.
Accept the GitHub Classroom assignment invitation by clicking the link in Moodle (located underneath the link you clicked to obtain this document) to create your repository. You will then be able to clone/link it into your own IDE as you have done in some of the lab classes.
Perform a textual analysis to identify potential classes (look for nouns), potential methods (look for verbs or actions), potential fields/data (look for nouns again). You will need to consider whether subclasses are needed. You may like to develop an initial class diagram to organise your thoughts (this is not marked.) You need to give much thought to what classes you might need, including ones not explicitly mentioned (but implied), and how they might need to interact or work separately.
Start coding, for example by taking one functional requirement to start with (but keep in mind the "Other Requirements" listed after the "Functional Requirements"). Identify how you might check/prove that it is addressed and correct. Write code to address the requirement. Once that functional requirement is fully addressed/working and tested, commit the code files to the repository (you can commit more frequently if you wish but try avoiding committing code with compiler errors), then work on another functional requirement and repeat the process. You can work on the requirements in whatever order you want - they do not all need to be done sequentially in the order they are provided.
When completed, finalise the repository on GitHub (make sure it contains the final version), then submit your supplementary document to Moodle. The marker will obtain your code from GitHub to mark you.

Background/Contextual Information
When a new house or industrial premises is to be constructed, it requires the engagement of a range of different trades people and requires different supplies of materials.
For example, a house typically requires a concrete slab, then frame-work, roofing, bricks, windows, internal walls, cabinetry (the cupboards and benches), flooring, electrical, gas and water networks.

Some houses additionally require landscaping work. Similarly, when an industrial premises is being built, there is the need to have the building constructed in stages.
These different aspects of the building work required to build houses or industrial premises, each have a cost and require a period of time. The way the costs and time of each stage are calculated differs. For example, pouring the concrete slab (on which a house is to be built) depends on the total area needing concrete. The price of brick-work depends on what type of bricks are used and how many bricks are required.
The intended user of this program would be someone who works for the company that "builds" the houses or industrial premises. The program will let them enter details about aspects of a particular building job, or to obtain this information from files, in order to calculate the exact cost and time required to build the house.
You are provided with an empty Eclipse Project and some example data files as a starting basis for you to commence the assignment work.
The following sections explain what the program needs to do (Functional Requirements), and then this is followed by some additional matters which must be addressed by the code you develop as the solution program.

Functional Requirements
The following are the Functional Requirements (FR) that the program must achieve.

FR-1: The program must be a text-console menu-based system
The program when started should be running through the console (using System.out for output, and Scanner for input) as was done in past tasks.
The program needs to allow the user flexibility in what actions they perform, and so you should be designing the user interaction to make use of menus, that is, you display to the user a list of the actions that they can perform, as a numbered list, and then the user selects the desired action by entering the corresponding number. A basic class/project is provided with comments indicating code you should insert to handle the menu processing.
The program must allow the user to do the following, as described in other functional requirements:
Add a new Building Job's details manually (FR-3)
Add a new Building Job's details using files (FR-13)
Display the details of a particular confirmed Building Job (FR-5)
Generate a summary report about all building jobs (FR-12)
Save data about all Building Jobs to a file (FR-14)
Restore data about all Building Jobs from a file (FR-14)
Quit (stop running when selected).

FR-2: Provision to represent information about Building Jobs
As is probably obvious, the program needs to be able to represent the details about a set of various building job contracts, and in particular, about the various works to be done during the building contract. The recommendation is to have a class named BuildingJob or similar in which to collate all the information pertaining to a particular building job/site.
Other functional requirements explained below specify the details about the types of works, but there is still a need for the information to be linked in a relevant way to the BuildingJob during the running of the program, and to access and use the information. You will be judged on the appropriateness of decisions you make regarding how to achieve this.

Every building job includes a fee for establishing the contract to build the property. This fee is
$12,000 for Houses (without landscaping), $21,000 for Houses with landscaped gardens, and
$18400 for industrial properties. Additionally, there is a 10% government tax charge, based on the total of all costs associated with the building job.
(Note: Landscaping for a house does not add any extra time to the duration of a BuildingJob, as it is considered to be done during the BuildingJob when other work is also being performed.)

FR-3: Add a new Building Job's details manually
There must be a functionality offered by the main menu that allows the user to add a new BuildingJob (for a house or industrial premises that is going to be built by the building company) to the system, setting-up its details manually - that is, through console-based input.
In the previous assignment, you simply typed in the total price of the house, but in this assignment that will be replaced with a process of specifying the details of (some of) the items, such as bricks and tiles and windows, etc.
When this function is selected, the program should ask the user to provide the address of the work site, and the type of build job (house, or industrial premises) to create a new BuildingJob which has no other details about the construction requirements yet.
It should then enter a "deciding" (or planning) mode where the user is able to add or alter aspects of the work required for the building job. For example, the user should be able to choose to add information about the concrete slab installation works, and the roofing works. Later (any time until the job is "confirmed"), they may need to replace the information about the roofing works with new information, and add other information such as details about the framing works or brick works.
The intention is that once the option from the main menu is selected for adding a new Building Job, that the program enters into a sub-menu mode. It does not leave this sub-menu mode until the Building job is "confirmed" and added to the system-wide collection of building jobs.
So, during the deciding mode (the sub-menu mode) it must be possible for the user to:
Provide details needed to create/replace an object that can represent the details about the concrete slab installation works required. This object should be added to an aggregation representing the "components" or materials of the house/industrial premises, which should be achieved using an ArrayList for this assignment.
Provide details needed to create/replace an object that can represent the details about the framing works that will be required. Again, the object should be added to the aggregation of materials/components.
Likewise, provide details to create/replace an object that can represent the details about roofing works.
Provide details to create/replace an object that can represent the details about brick works.
Provide details to create/replace an object that can represent the details about window and external door works.
Provide details to create/replace an object that can represent the details about window and external door works.
Provide details to create/replace any objects that represent information about electrical or plumbing work.
Display detailed information about all the work and costs involved for the building job, based on the work that is currently associated with that building job. (see FR-4 below.)
Confirm that the building job is now ready to be treated as "confirmed", which means no further additions or changes can be made for that building job. You can make a building job "confirmed" even if some of the details about work are not actually set for the building job - but at least one of the details must have been set to allow the building job to change to confirmed.

The details of how what details are required to be obtained for each of the above, is explained in later FR's.
After the building job has been set to "confirmed" (i.e. all details about required work have all been added to the BuildingJob), then the BuildingJob itself should be added to a separate aggregation that represents all of the building jobs that have been created so far. Do not add the building job to this aggregate until it has been confirmed.

FR-4: Ability to display the details of a BuildingJob on the console
There must be a possibility to report the details of a particular building job's items of work. This is required in several places in the program.
It should begin by reporting the address of the chosen building job, then what type of building job it is, then the total number of days required for all the building work to be done. This is then followed by the details of each of the component stages of the job, i.e. the concreting work, the framing work, the brick work, etc..
Most stages involve several items that need to be reported as separate lines (e.g. the materials on one line, the labour on another). You need to give as much detail as is possible, for example show the quantities, the rates, the units of measurement, colours, etc. as is done in the example below.
At the end, the contract fee should be included, then the total cost (before tax) after having calculated it from all of the component stage prices. Next should be the 10% government tax amount (calculated from the total cost). Finally you should report the overall cost (the before tax cost, plus the tax amount).
The following shows an example of what is expected to be displayed for a particular building job:

Building Job site: 64 Summer Boulevard, Kew
Type: House
Total Days required to build: 55 days
Details of components/stages:
Concreting: Requires 10 days
246.6 m2 @ $27.40 per m2 6740.40
labour costs 2000.00

Framing work: Requires 6 days
Pine Frames: 522 m @ $21.20 11066.40
Labour costs 2400.00
Roof Work: Requires 6 days
Tiles: 310.5 m2 @ $95.00 per m2, colour: Grey 29497.50
labour and set-up costs 1520.00
Brick work: Requires 17 days
5700 medium quality @ $5.50, color: Brown 31350.00
labour costs 3050.00
Windows: Requires 4 days

3 small windows @ $800.00 2400.00
6 large windows @ $1520.00 9120.00
2 sliding doors @ $2100.00 4200.00
1 swing-open door @ $380.00 380.00
Labour costs 750.00
Electrical work: Requires 7 days Labour costs - 7 days @ $230 per
day
1610.00

Plumbing work: Requires 5 days
Labour costs - 5 days @ $243 per day 1215.00

Contract Fee - House (no landscaping) 12000.00
TOTAL COSTS: 119298.90
Government Taxes: 11929.89
AMOUNT DUE: 131228.79

The exact order of the different component stages is not important - generally it would correspond with the order in which the individual components were added to the aggregate. It also would only include those items/stages which have been added to the building job so far.
You should try to make the number values line up in columns with the decimal points aligned.
Note regarding the windows and doors: If there are 0 of some type, then the line for that type does not need to be included in the output - e.g. if there were 0 sliding doors, you don't show a line for sliding doors.

FR-5: Display the details of a particular BuildingJob at any time
The program's main text-console menu system should provide the ability to display the details of any building job that has been added to the system.
When this menu option is selected, it should display a numbered list of addresses of all the "confirmed" building jobs that have so far been added to the system (whether manually, or using data from files), to allow the user to select a particular one that they want to see the details for.
It would then display the building job's details as explained in FR-4.

FR-6: Record and Calculate information about Concrete Slab installation works
The program must have provision for representing information about the costs and time involved in the work to create a concrete slab (a solid base of concrete on top of which the house/premises will be built), and of being able to report that information in various forms when required by other parts of the program later on. You will need to obtain sufficient information during the process of creating the building job.
The people who create the concrete slab have advised that the cost of their work is calculated the following way:
They need to know the total area, in square meters (m2), for the concrete. This value could have a fractional part, e.g. 46.8 or 33.2 are examples.
There is a cost of $27.40 per square meter required (so multiply the previous by this value)
There is a labour cost of $2000 just to come and do the work, which includes setting up for pouring the concrete, and then actually pouring the concrete, then removing the setup.
It requires 10 days for every concrete slab: 1 day to set up, 1 day for the actual concrete to be delivered and the remaining time is for the slab to dry.

FR-7: Record and Calculate information about framing works
The program must have provision for representing information about the costs and time involved in the work to prepare and assemble the framing works, and of being able to report that information in various forms when required by other parts of the program later on.
The program needs to ask whether pine (a type of wood) or steel will be used. Steel costs more, but is stronger. The frame works are required for all internal and external walls and to hold up the roof.

The people who create and assemble the framing have advised that the cost of their work is calculated the following way:
They need to know the total length of framing required. This is measured in meters (m) rounded to a whole number. A typical house would require several hundred meters worth,
e.g. 373m or 581m (usually pine). A typical industrial premises might require about 150-250 meters (usually steel).
The price of pine is $21.20 per meter required. Steel is $43.70 per meter.
The time required to prepare and install the framing depends on the quantity (the total meters) - there is at least 3 days, plus another 1 day for each 200 meters (or part of 200 for the last part - for example, 581m is considered 3 amounts of 200m).
There is a labour cost of $400 for each day required (including the 3 days).

FR-8: Record and Calculate information about Roofing works
The program must have provision for representing information about the costs and time involved in installing the roof, and of being able to report that information in various forms when required by other parts of the program later on.
There are three main types of roofing, either tiles, unpainted steel (usually for industrial cases) or painted-steel (usually on houses). The program needs to ask what type of roofing is desired.
The people who assemble roofs have advised that the cost of their work is calculated the following way:
They need to know the total area of roofing required. This is measured in whole square meters (m2). For example, a rectangular house of 10 by 20 meters has a floor-area of 200 m2, but because the roof is angled, that means the area of the roof is larger, for example maybe 240 m2.
They need to know the type of roofing desired (tiles or steel).
They need to know the colour of the roofing. Tiles and painted steel are in various colours. Unpainted steel is silver.
The price of materials to construct the roof is: $95 per square meter for tiling, $65 per square meter for painted steel. For unpainted steel, it is $47 per square meter.
The time required is at least 2 days, to set up scaffolding and take down the scaffolding, plus the following: Steel (both painted and unpainted) requires 1 extra day for every 400 m2 of roof area, and tiles require 1 day for every 80 m2 of roof area.
There is an additional basic labour cost of $600 for the roof people to do any work, and an additional labour cost of $230 per extra day that they are required for actual roof installation work (i.e. not charged on the days when scaffold is being set up or taken down).

FR-9: Record and Calculate information about Brick works
The program must have provision for representing information about the costs and time involved in doing the brick-work to make the external walls of houses only (as most new houses these days have bricks around the outside of the house), and of being able to report that information in various forms when required by other parts of the program later on. It is possible, but not common, for industrial premises to be brick, but for the purposes of this program assume that bricks are used for the industrial premises exterior walls.
The people who do the brick-work have advised that the cost of their work is calculated the following way:
They need to know how many bricks are required. For example, a 1m2 portion of wall with no window/door would typically use about 60 bricks.
For the example house of 20x10 meters floorspace, it has an outside perimeter of 60 meters. If the height of the walls is about 2.4 meters, this would be a total area (before considering windows/doors) of 144 m2. So after taking away some space for windows, it might be about 97 m2, which would require about 5820 bricks.They need to know which quality type the bricks should be. Low Quality bricks are $3.10 each, Medium Quality bricks are $5.50 each and Premium Quality bricks are $7.20 eachThey need to know what colour the bricks should be. There are a range of possible colours such as "light brown" or "light red" etc.There is a base labour charge of $1350 just to have the bricklayers come to do any work, and ...They require 1 day for every 600 bricks that need to be laid. (So 5820 bricks would require 10 days).They charge an extra $170 for each day that is required for them to do work.There needs to be at least 7 days after completion of the work, before any other work can be done, to let the mortar dry (between the bricks). There is no charge for these days but they are still counted in the number of days required to complete the brick work.Also note FR-16

FR-10: Record and Calculate information about Window and External Door installation works
The program must have provision for representing information about the costs and time involved in the work to install windows for a new house, and of being able to report that information in various forms when required by other parts of the program later on.
The people who install windows, have advised that the costs for having windows installed are calculated in the following way:
They need to know how many ‘Small' windows there will be. These cost $800 each.
They need to know how many ‘Large' windows there will be. These cost $1520 each.
They need to know how many ‘Sliding door' windows there will be. These cost $2100 each.
They need to know how many ‘Swing-open' doors there will be, These cost $380 each.
There is an additional labour charge of $750 just to have the people come to do the work, regardless of how many days work there is (it is charged just once).
The time required for the windows and external doors to be installed is based on how many there are. They can do 4 per day (of any size/type).
Also note FR-15.

FR-11: Record and Calculate information about Electrical and Plumbing work
The program must have provision for representing information about the costs and time involved in the work to install electrical wiring, power sockets, and all the plumbing work for gas and water, and of being able to report that information in various forms when required by other parts of the program later on.
The people who do these types of work, have advised that the cost of their work is as follows:
Electrical work costs $230 per day. They require at least 4 days, but will do no more than 10 days. The exact number of days is decided when arranging for them to work on a particular building job/project (i.e. when setting up the building job)
Plumbing work costs $243 per day. They require at least 5 days, but will do no more than 8 days. Again, the number of days is decided when arranging for them to work on a particular building job/project.

FR-12: Generate a summary report about all confirmed building jobs to a text file.
When the menu item for this FR is selected, the program will ask the user to specify a name for a file that it will generate a report into.
The report should show a heading to describe the purpose of the report. Then it should report summary information about all the confirmed building jobs that the system knows about in the following manner:
One line should provide the address of the building job.
The next line should show the total build cost (inclusive of the government tax)
The next few lines should be to show for each type of work that is required for the build job, a statement of how many days work will be required to complete that stage of work.
At the final line of that building job's summary, it should state the total number of days required to complete the whole building job, and the total amount of labour-related costs for all the work (i.e. not including the costs for items used in doing the work).
All lines except the address lines, should be indented a little to the right.

FR-13: Add a new Building Job using details from a text file
There must be a separate functionality offered by the main menu that allows the user to "Set Up" the details of a new Building Job but this one will obtain the relevant data from a text file instead of from the user. The data is always about a plain house (i.e. not an industrial premises or a house with landscaping).
Before reading data from the file, when this FR is started the program should ask the user to provide the address of the job site, to be able to create the new object representing the building job which has no details about the construction stages or materials yet.
The program should then ask the user to specify the name of a file which is a text file containing the details of the requirements for a new building job. This information needs to be read into memory, to create suitable objects that represent the information in the building job.
You should assume that all the possible data files that will ever be processed for this FR conform to the following structure inside the file:
The first line is information about the concrete slab. It will specify the total area in square meters (m2) as a number (with a fractional part) describing the area required for the slab.
The second line is information about the framing. It will have an integer specifying the total length of framing required, followed by either Wood or Steel indicating the type of framing.
The third is information about the roof. It will start with either the word Tiles or else the word Steel indicating the type of roof to be added. Next will be a number specifying the m2 amount of the roofing area required. The remainder of the line will be the colour (note some colours involve 2 or more words, as in Light Grey for example).
The fourth line will have information about the brick work. The first thing is a number that specifies how many bricks are required.
That is followed by a second number on the line, which will be an integer indicating the brick quality type. The value 1 will mean low quality, 2 will mean medium quality, and 3 will mean premium quality
The remainder of the fourth line will be a description of the colour of the bricks, such as "Light Brown".
The fifth line will specify the window and external door requirements with 4 numbers. The first number is how many ‘Small' windows are required. Next number is how many ‘Large' windows are required. Third will be how many Sliding Doors are required, and the last number is how many swing-open doors there will be.
The sixth line will specify the number of days of electrical work that is required, followed by the number of days of plumbing work required.

After obtaining the relevant data from the file, you need create suitable objects that can represent the details, and then these objects should be added to the aggregation of materials/component stages for the BuildingJob object that is being set-up. Then, once all is completed for that BuildingJob, it should be added to the system as a "confirmed" building job.
Some sample files are included in the GitHub repository when you get access to it.
Note that the marker may use different text files to test your program, but the content of the files will conform to the description given above.

FR-14: Preserve the information about building jobs between runs
There should be a menu item to let the user save all the data about all the confirmed Building Jobs to a serialized file. There should be a separate menu item to let the user load all the data about previously serialized building jobs, to bring them back into memory - which will replace any jobs that are currently in memory with the ones that were read in from the file.
You can use whatever name you like, for the file which stores the serialized data.

FR-15: Obtain details of required Window and External Door installation works using a GUI Frame
During the phase when a building job is still being set up, if the user chooses to add the details regarding the windows and external doors (see FR-10) they should be presented with a GUI Frame, rather than using the console to provide the information. (NOTE: The text console will very likely just continue on to whatever it does next, such as presenting the menu of user options of tasks to do. That is fine, just don't type anything into the console until the GUI frame is eventually closed.)
(In the early stages of developing the code, it is ok to obtain the information using the Scanner, but eventually you should aim to replace such a technique with a GUI for obtaining the Window and External Door installation work information. If you want, you can skip making a Scanner based input process for this.)
The GUI frame should be asking the user to specify how many ‘small' windows, how many ‘large' windows, how many sliding doors and how many swing-open doors are desired. As the user enters values, the GUI frame should update some labels which report cost-estimates so that the user will know the cost that the items will add to the building job. It should separately update/show the number of days of work that is required based on the inputs the user has specified.
Once the user is happy to confirm their selections, they should click a specific button which will then add or update the details in the current building job, and close the GUI frame - but only if sensible inputs were provided (e.g. no negative numbers). Missing inputs should be considered as being zeroes.

FR-16: Obtain details about brick-work requirements using a GUI Frame
During the phase when a building job is still being set up, if the user chooses to add the details regarding the brick-work (see FR-9) they should be presented with a GUI Frame, rather than using the console to provide the information. (NOTE: The text console will very likely just continue on to whatever it does next, such as presenting the menu of user options of tasks to do. That is fine, just don't type anything into the console until the GUI frame is eventually closed.)
(In the early stages of developing the code, it is ok to obtain the information using the Scanner, but eventually you should aim to replace such a technique with a GUI for the brick-work information.)
The GUI frame should be asking the user to specify how many bricks are required, the colour to use, and to specify whether they want low quality, medium quality or premium quality bricks.

There should be a button to click that will calculate and present an estimate of the cost of the number of bricks (of the chosen quality type), and separately present an estimate of the labour costs that would be involved (based on the number of bricks). It should separately show the number of days of work that is required based on the inputs the user has specified.
Once the user is happy to confirm their selections, they should click a specific button which will then add or update the details in the current building job, and close the GUI frame - but only if sensible inputs were provided. Missing inputs should be considered as being zeroes.

Other Requirements:
These are other things you must address or consider while developing your solution. See also the marking guide at the back.

OR-1: Use Git to keep track of incremental development work and to work collaboratively
You are required to make use of a GitHub repository as created by the GitHub Classroom to keep a record of the progress as you work through this assignment. Using Git is a skill expected in industry, but in this assignment you will be the only person using the repository. To create this repository, you will need to "accept" the GitHub Classroom assignment "invitation" for this assignment, found on Moodle. You would then need to import the project from the repository into Eclipse, by using the "Import from Git" option in Eclipse to create the clone of the project on your computer.
You will use the git repository to demonstrate that you have taken an "Incremental development" approach to completing the assignment. This means that you are gradually working towards a goal, and are evolving the system's functionality as time proceeds. You should be working on solving one functional requirement or aspect of the system at a time. As you complete each aspect of the system, you should commit that to the repository. However, you should only be committing code that is free of syntax errors (and hopefully free of logical errors), which compiles without errors.
As part of your submission to Moodle, you should include (in the overview document mentioned in OR-2) the URL of the repository created by GitHub Classroom that contains your group's committed code. You do not submit any code to Moodle - only the code that is in the repository on the main branch will be marked by the marker.
The marker will be examining your repository's commit history in depth, and checking that you followed an incremental approach.

OR-2: Complete a written support document
Some of the following other assessment requirements here, require you to write some things in a document to be submitted to Moodle. You should create a document (in Microsoft Word) and include those written things.

OR-3: Must use inheritance and make subclasses
A primary purpose of this assignment is to assess your ability to use inheritance in appropriate ways and places. Whilst it is possible to complete this assignment without inheritance, the solution would be less ‘elegant' (and more complex/messy).
You should think about what parts of the problem lend themselves to the use of subclasses, inheritance, overriding, etc.
In your written support document, explain 2 completely different parts of the program where you have used inheritance, and explain why you needed to use inheritance for those parts. Also explain at least one case you have used overriding, and say why that was an appropriate place to use it.

OR-4: Must demonstrate polymorphic method calls and have polymorphic variables
Your code is expected to make use of polymorphic variables and to involve polymorphic method calls.
In the written document, explain where/how you have used polymorphic method calls in relation to your domain classes (but not other types of classes). Explain why you consider it to be polymorphic.

OR-5: You need to consider what set of classes may be needed to make things "work"
For the functional requirements to be met will require a range of classes to be written by you. Some of these may be obvious from the descriptions given earlier. But you will need to consider more completely what set of classes are required to fully enable the program to be realised.
(You might like to develop UML class diagrams to help you work out or understand the structuring of the program - these will not be marked and do not need to be submitted).
You will also be assessed on the appropriateness of choices of classes, and of other programming constructs used in your code (such as methods, fields, constants).

OR-6: JUnit Tests for some classes
You need to write several JUnit tester classes. In particular, the class that represents the building job, should have a few test cases to confirm that it is correctly calculating several things. You should also make sure that at least 2 other classes that signify particular types of work that are done as part of a building job, have test cases written as well. It is best to write the tests when you are writing the specific class that the tests are testing.
In writing test cases, try to make use of a variety of assertions.
In writing test cases, try to show both that things which are meant to work, do work, and also that some things which are not meant to be possible, are not possible.
Include a comment before each test case to explain what it is trying to test/prove.

OR-7: Other code constructs/elements/techniques that must be used
You are expected to make use of the following at appropriate places in the code:
Use selection/decision constructs
Use repetition/looping constructs
Use ArrayLists in appropriate places
Implement aggregation in appropriate places
Follow recommended techniques for the appropriate naming of variables, parameters, methods and classes. (And do not use abstract names devoid of context such as decision1, decision2, input4, blah, val, as these names do not make any sense to humans about the purpose or meaning of the values inside them.)
Use the Scanner class for keyboard input (except when the GUI Frame is in use).
Use in-code documentation to explain significant segments of code (e.g. an explanation of each method's purpose, the meaning of the parameters, the meaning of the returned value)
Use proper indentation of code within blocks
Additionally, you are expected to write all the code yourself. Do not share your code with anyone else.