1 Task 1: Complete Weekly Java Tutorial Videos

• For Lab6, you are assigned to study Week 7 Part A to Part C1 and Week 8 (available on March 5) of the Java tutorial series:

https://www.youtube.com/playlist?list=PL5dxAmCmjv_7x3Qn5px_zS0qqgaBK9Sc1	[ Week 7 only ]
https://www.youtube.com/playlist?list=PL5dxAmCmjv_6JyoGf4zvQmg3piNzipWdb To reference tutorial videos from the previous weeks, see:	[ Week 8 only ]
https://www.youtube.com/playlist?list=PL5dxAmCmjv_6wy2m0yq2wObIWPz4tAxW6	[ All Weeks ]

These Java tutorial videos assigned to you are meant for you to:

1. Obtain extra hands-on programming experience on Java, supplementing your weekly lectures.
2. Complete the lab assignment with the necessary skills and background.

Though we do not require the submission of the weekly Java tutorial project (like in Lab0), examples and insights discussed in these tutorials will be covered in your (written and programming) tests and exam: should you decide to skip the weekly tutorial videos, it would be your choice.

As you study through the example Java classes in the tutorial videos, you are advised to type them out (but absolutely feel free to add new Java classes to experiment) on Eclipse.

• You can find the iPad notes of illustrations from the tutorial videos here:

https://www.eecs.yorku.ca/jackie/teaching/tutorials/notes/EECS1022%20Tutorial%20on%20Java.pdf

Important Notes to Read (New)

• See this notes on how to manipulate objects with reference-typed, multi-valued attributes:

https://www.eecs.yorku.ca/jackie/teaching/lectures/2021/W/EECS1022/notes/EECS1022_W21_Tracing_ PointCollectorTester.pdf

Notes from Lab5

• See this notes on how to infer classes and methods from given JUnit tests:

https://www.eecs.yorku.ca/jackie/teaching/lectures/2021/W/EECS1022/notes/EECS1022_W21_Inferring_ Classes_from_JUnit.pdf

• You can find here the example covered in the notes for practice:
  • Starter: https://www.eecs.yorku.ca/jackie/teaching/lectures/2021/W/EECS1022/notes/EECS1022_ zip
  • Solution: https://www.eecs.yorku.ca/jackie/teaching/lectures/2021/W/EECS1022/notes/EECS1022_ zip

Getting Prepared for Programming Test 3

• Your Programming Test 3 will cover classes and objects, and its format will be (virtually) identical to this lab (and Lab5).

2 Task 2: Complete Programming Exercises

Starting Task 2 should mean that you have already completed the weekly Java tutorial videos (Section 1).

2.1 Step 1: Download and Import the Starter Project

1. Download the Eclipse Java project archive file from eClass: zip
2. Launch Eclipse and browse to EECS1022-W21-workspace as the Workspace then click on Launch, e.g.,

3.3 Choose Select archive file. Make sure that the EECS1022W21Lab6 box is checked under Projects.

2.2 Step 2: Programming Tasks

From the Package Explorer of Eclipse, your imported project has the following structure.

• The consoleapps package is empty. You may add new console application classes here to test the implemented methods if you wish. However, these added console application classes will not be graded.
• It is expected that the TestOnlineSchool JUnit class contains compilation errors. This is because that declarations and definitions of the required class(es) and method(s) it references are missing.
• The model package is empty. Class(es) and method(s) derived from the given JUnit class must be added to this package. Class(es) added to a package other than model will not be graded.

Therefore, your tasks are:

1. Inferring from the given JUnit tests, add the missing class(es) and method(s) into the model For example, if you add class Foo in the model package, make sure that you write a line in the beginning of the TestOnlineSchool class (after the line package junittests;):

import model.Foo;

2. Pass all JUnit tests given to you (i.e., a green bar).

To run them, as shown in the Java tutorials on Week 1, right click on TestOnlineSchool.java and run it as JUnit tests. Of course, none of the given tests would pass to begin with.

You must not modify these given JUnit tests, as they suggest how the intended class(es) and method(s) should be declared.

How to Deal with a Failed JUnit Test? From the JUnit panel from Eclipse, click on the failed test, then double click on the first line underneath Failure Trace, then you can see the expected value versus the return value from your implemented method.

2.3 The Online School Problem

You are required to develop an object-oriented program solving a (simplified) online school problem, where there is a list of participants registered in courses taught by qualified instructors:

• Each instructor is characterized by their name, campus phone extension (e.g., 70310), and contact email.
• Each registration is characterized by its subject title, numerical marks, and instructor (who may not be assigned when the course is first created).

Given a registration object:

• A grade report may be returned as an array of length 2, e.g., {B, Good}, where the first element stores the letter grade and the second element stores its qualitative description. Consider the following table summarizing how each numerical marks (assumed to range between 0 and 100) maps to its grade, description (whose spellings should be exact), and grade point:

Range of Raw Marks	Letter Grade	Qualitative Description	Grade Point
90 100	A+	Exceptional	9
80 89	A	Excellent	8
70 79	B	Good	7
60 69	C	Competent	6
50 59	D	Passing	5
0 49	F	Failing	0

• A string information object may be returned. There are two cases to consider, depending on whether or not the course instructor has been assigned. In the case where the instructor is present, the returned string should contain the course title, instructor name, the marks, and its corresponding grade and description (see the above mapping table).

• Each participant object is characterized by the name of student and the list of added registrations.

Given a participant object, we may:

• Add a new registration, either by an input registration object, or by the name of course (from which a registration object may be created accordingly). The maximum number of registrations allowed for a participant is 5: attempting to add registrations beyond this limit will have no impact (i.e., the list of registrations remains the same). Furthermore, there is no need to check if there are duplicated registrations added (e.g., two registrations with the same course name).
• Retrieve its list of registrations as an array (i.e., Registration[]), whose length is less than or equal to the maximum allowable number (i.e., 5).
• Clear its list of registrations (e.g., allowing further registrations to be added).
• Retrieve the marks of a course with the given name. If the name of a non-registered course is given, then return -1 as its marks.
• Update the marks of a course with the given name. If the name of a non-registered course is given, then nothing should be changed.
• Obtain a report of the GPA (grade point average) over the list of added registrations.

• Each online school object is characterized by its list of participants.

Given an online school object, we may:

• Add a new participant by an input participant object. The maximum number of participants allowed for a school is 100: attempting to add participants beyond this limit will have no impact (i.e., the list of participants remains the same). Furthermore, there is no need to check if there are duplicated participants added (e.g., two participants with the same name).
• Retrieve the list of participants of a course, given its name, as an array. If the input name denotes a non-existing course, then an empty array is returned.

• Other intended functionalities of above kinds of objects can be inferred from the given JUnit test class TestOnlineSchool.

2.4 Hints and Requirements

• See this notes on how to declare and manipulate reference-typed, multi-valued attributes:

https://www.eecs.yorku.ca/jackie/teaching/lectures/2021/W/EECS1022/notes/EECS1022_W21_Tracing_ PointCollectorTester.pdf

Try to finish the above notes before Week 8 Java Tutorials are released (March 5).

• See this notes on how to infer classes and methods from given JUnit tests:

https://www.eecs.yorku.ca/jackie/teaching/lectures/2021/W/EECS1022/notes/EECS1022_Inferring_ Classes_and_Methods_from_JUnit_Tests.pdf

Programming IDEs such as Eclipse are able to fix such compilation errors for you. However, you are advised to follow the guidance as specified in the notes to fix these compilation errors manually, because: 1) it helps you better understand how the intended classes and methods work together; and 2) you may be tested in a written test or exam without the assistance of IDEs.

• Any new class(es) you add must reside in the model
  • Once the necessary class(es) and method(s) are declared, you can add as many attributes as necessary to implement the body of each method.
  • Study carefully example instances as specified in java: they suggest the how the intended class(es) and method(s) should be declared and implemented.
  • Focus on gradually passing one test at a time.
  • You cannot use any Java library classes (e.g., ArrayList) or methods for implementation. That is, there must not be any import statement in the class(es) you add to the model

2.5 Step 3: Exporting the Completed Project

You are required to submit a Java project archive file (.zip) consisting all subfolders.

In Eclipse:

3. Check the top-level EECS1022W21Lab6

Make sure that all subfolders are checked: .settings, bin, and src.

Under To archive file: browse to, e.g., desktop, and save it as EECS1022W21Lab6.zip (case-sensitive)

Note. In case you have concerns about exporting and submitting the .setting subfolder: it will be kept confidential and access-protected on eClass.