COSC2452-Assignment 3 Solved

For this assignment, assume that you are a freelance programmer creating a small tool or a utility program of your own choosing to add to your portfolio of simple Java applications. With this project you aim to demonstrate to potential employers or clients how you can:

1.  Create a small tool or utility program using (exclusively) a limited set of fundamental code concepts.

2.  You are able to analyse and evaluate your implementations against possible alternatives in your code documentation.

You must meet Functional Requirements (4.1), Code+Justification Requirements (4.2) and Documentation Requirements (4.3) to obtain the full mark for this assignment. 

4.1) Functional Requirements:

Important: The functional requirements below must be implemented and justified by following the 4.2 Code+Justification requirements.

F1) Allows the user to store an arbitrary number of records. May store more than 1 type of record.

F2) Allows the user to add, remove, modify such records.

F3) Allows the data for the records to be loaded from files and saved later in to a file.

F4) Has no restrictions on how many user interfaces can be used simultaneously in the system.

Tip: As you are not given marks for creativity or the usefulness of the program, do not spend too much time thinking of what is a 

“good” program. What is good depends on how well the code is written, justified and documented (refer to sections 4.2 and 4.3).
4.2) Code+Justification Requirements 

To receive marks for Code+Justification requirements, you must use the following Application.java template and code concepts to make a functionally cohesive program that also meets the functional requirements.
public class Application { private BackEnd backEnd; private FrontEndGTerm uiGT; private FrontEndConsole uiConsole;

public Application() { this.backEnd = new BackEnd();

this.uiGT = new FrontEndGTerm(this.backEnd); this.uiConsole = new FrontEndConsole(this.backEnd);

}

public static void main(String[] args) {

Application app = new Application();

}

}
 

The above file must not be changed by it should be possible to create multiple FrontEndGTerm objects to use the same BackEnd.

Concepts must be used exclusively as demonstrated by Gayan’s weekly live lectures in this course offering. Code without justification in the given format would attract no more than 50% of the mark allocated for that component. Comments without code will not attract any marks.

An important note on Java code validity: A program with even one red dot (compilation error) cannot be tested and therefore will attract 0 marks for the entire submission. Test your code thoroughly.
Code concept
Code requirements below must also be justified as required
CJ1) Muti class 

Object Oriented 

Code 

 
Requirements: +3 marks each for each + below when implemented as shown during Gayan’s live lectures

+ Correctly uses the provided Application.java template to organise code by following OO concepts covered in main weekly live lectures by Gayan. (Application+BackEnd+FrontEndGTerm+FrontEndConsole and additional justifiable class(es) in the BackEnd) + Must create at least one more class to reduce code/logic duplication and have an array of this type in the BackEnd. 

Other deductions: -2 marks for each - below

-                 The Application class submitted (the version provided in this document will be added by marker at time of marking) or has more than one class per submitted .java file.

-                 Application class has been split further in to additional class(es). 

-                 One or more FrontEnd classes have been split further in to additional class(es). 

-                 GTerm or user interface mentioned outside of FrontEndGTerm class.

-                 Scanner, System.out, System.err, etc. mentioned outside of FrontEndConsole class.

-                 Has at least one object member variable that is not explicitly private.
CJ2) Other general 
Requirements: +0.5 marks each for each + below when implemented as shown during Gayan’s live lectures

+ Descriptive identifier names which are relevant to their purpose. Follows naming conventions shown in lectures, other standard class materials and common ones in the Java API.

+ Consistent formatting used. Comments and justifications start on the line before the documented block/statement (e.g. no in-line comments).

Other deductions: -0.5 marks for each - below

-                 Includes irrelevant or unreachable code+comments.

-                 Uses break, continue, System.exit or similar branching anywhere in the code - Uses return in the middle of methods- Has at least one mention of static.

-                 Has at least one mention of static.

-                 Paths contain folders/slashes (e.g. addImageIcon, file I/O, etc.)
CJ3) Variables (
Requirements: +0.5 marks each for each + below when implemented as shown during Gayan’s live lectures + Demonstrates understanding of suitability of primitive data types vs. class.

+ Declares variables in blocks where they need to be declared (avoids unnecessary “sharing” of  declarations)

Other deductions: -0.5 marks for each - below

- Uses variables when literals would have been suitable. - Uses literals when variables would have been suitable.
CJ4) Methods 
Requirements: +0.25 marks each for each + below when implemented as shown during Gayan’s live lectures + Each class has exactly one constructor

+ Methods are created when absolutely necessary or when they reduce duplication of code. + Methods return values when suitable (e.g. accessor/get methods) + Methods take parameters when suitable (e.g. mutator/set methods).

Other deductions: -0.25 marks for each - below

-                 Not all object member variables, arrays, etc. declarations are explicitly initialised in this constructor before any other operations (e.g. there are no equal signs where member variables are declared).

-                 Has examples of methods referring to an object member variable without using this. (“this dot”)
CJ5) User interface 

(FrontEnd…) classes 

 
Requirements: +1 marks each for each + below when implemented as shown during Gayan’s live lectures

+ FrontEndGTerm uses GTerm exclusively for inputs and takes most, if not all, inputs via text fields/text areas/password fields (vs. getInputString). FrontEndGTerm uses GTerm exclusively for outputs and displays most, if not all, outputs within the GTerm window (as opposed to using .showMessageDialog...)

+ FrontEndConsole uses Scanner’s .nextLine() exclusively for inputs (e.g. must not use other .next... methods).FrontEndConsole shows text-based menus and formats outputs in to tables, etc. as shown in weekly live lectures.

Other deductions: -1 marks for each - below

-                 FrontEnd… classes do not offer an identical set of functionalities to the end-user.

-                 A FrontEnd… class has awareness of another FrontEnd class/object.

-                 A FrontEnd… class has awareness of a custom class/object that should only be used by BackEnd (e.g. A FrontEnd must not communicate with a custom class type used by BackEnd’s primary array.) - Creates multiple Scanner objects.
CJ6) Conditional execution and repetition (
Requirements: +0.5 marks each for each + below when implemented as shown during Gayan’s live lectures

+ Uses if/else/else if appropriately and exclusively for non-repeating conditional execution and at least one reachable else if statement. 

+ Uses while-loops appropriately and exclusively for repetition. Loop condition describes all situations under which the loop will repeat and condition fails eventually.

Other deductions: -0.5 marks for each - below - Conditions include tautologies.

- Redundant conditions. 

- Unreachable blocks. 
CJ7) Arrays

(not ArrayLists, etc.)

 
Requirements: +1 marks each for each + below when implemented as shown during Gayan’s live lectures

+ All array manipulation performed using loops, if-statements, etc. (as shown in weekly live lectures by Gayan)

+ The size of the array mentioned in CJ1.Addition.2 should be able to vary at run-time. Run-time expansion allowed.

Other deductions: -1 marks for each - below

- Uses Arrays class

- Uses System.arraycopy

- Uses other classes (not covered in weekly live lectures) for array manipulation
CJ8) File 

input+output from 

BackEnd

 
Requirements: +3 marks each for each + below when implemented as shown during Gayan’s live lectures + Allows the user to load records from files specified at run-time. + Allows the user to save all data to a file specified at run-time.

Other deductions: -1 marks for each - below - Does not use CSV when appropriate.

- File reading code not in the most appropriate class.

- File writing code not in the most appropriate class.

- Does not use only BufferedReader+FileReader when reading.

- Does not use only BufferedWriter+FileWriter when writing.

- Keeps files open when not necessary to do so.
Justification Requirements

Note: You will not receive full marks for the CJ requirements unless each occurrence is justified as required below. 
Type of code
Compare and justify your choice over other possible alternative...
Declarations

(also applies to class and method definitions)
Identifier names Data types

Locality of declaration (why object-level vs. parameter-level vs. method-level vs. block-level, etc.).
Contents of code blocks
Formulations (is there a simpler way to meet requirements without creating this code block?)

Inclusions (what you have added and why?)

Sequences (why are these in this order?)

Exclusions (what you haven’t added and why)
Conditions
Formations of the logic
 
 
 
4.3)           Documentation Requirements Important note: Documentation must match with testable, functional and justified code to attract marks.

D1. Create an illustrated PDF user guide (one file). Must have side-by-side instructions on how to perform the same functionalities on both interfaces. Shows screenshots of sample inputs. Shows screenshots of corresponding sample outputs. Must include examples of using files to load and save. Include instructions on what the user can and cannot do (e.g. what they can and can’t input). Does not include any references to code as the guide is intended for a user who is not a programmer. This document needs to be professionally presented, more structured, starting with a table of contents, page numbers, clearly marked sections, etc.