Course Outline

Course: EECS 1030 3.0 Introduction to Computer Science II
Course Webpage: moodle.yorku.ca and www.eecs.yorku.ca/course/1030
Term: Summer 2015

This course continues the separation of concern theme introduced in EECS 1020. While EECS 1020 focuses on the client concern, this course focuses on the concern of the implementer. Hence, rather than using an API (Application Programming Interface) to build an application, the student is asked to implement a given API. Topics include implementing classes (utilities/non-utilities, delegation within the class definition, documentation and API generation, and implementing contracts), aggregations (implementing aggregates versus compositions and implementing collections), inheritance hierarchies (attribute visibility, overriding methods, abstract classes versus interfaces, inner classes); generics; building graphical user interfaces with an emphasis on the MVC (Model-View-Controller) design pattern; recursion; searching and sorting (including quick and merge sorts); linked lists; and stacks and queues. The coverage also includes a few design patterns.

Lab tests are integral parts of the assessment process in this course.

Prerequisites: EECS 1020 3.0 or EECS 1720 3.0
Course Credit Exclusions: ITEC2620 3.0

Course Instructor

Instructor: Steven Castellucci
Office: Lassonde Building, office 3048
Email: steven_c@yorku.ca
Office hours: TBA

Time and Location

Lectures: Curtis Lecture Hall G, Tuesdays and Thursdays, 17:30-20:30
Labs: Lassonde Building 1002, 1004, and 1006, Tuesdays and Thursdays, 20:30-22:00

Labs will be held during the first week of the term. Students should attend the lab for which they are registered.

Learning Outcomes

• Implement an API (Application Programming Interface).
• Test the implementation.
• Document the implementation.
• Implement aggregations and compositions.
• Implement inheritance.
• Use recursion.
• Implement linked lists.
• (Informally) prove that recursive algorithms are correct and terminate.
• (Informally) analyze the running time of (recursive) algorithms.

List of Topics

Below you find a detailed list of topics covered in the course. Items marked with an asterisk (*) may not be covered.

Implementing Static Features

• identify, correctly use, and implement utility classes
• explain what the static modifier means for attributes and methods
• use and draw UML diagrams for utility classes
• draw memory diagrams for utility classes
• define what the access modifiers public and private mean for attributes and methods
• explain how the choice of access modifier affects encapsulation
• define what the final modifier means for attributes
• explain why utility classes have a private constructor
• implement static attributes for a utility class
• implement static methods for a utility class
• write tests for static methods
• explain the difference between arguments and parameters
• explain how local variables can shadow class attributes
• explain the difference between preconditions and validation
• implement static methods that use parameter validation
• add documentation to a utility class using Javadoc
• implement static methods having interfaces as parameters
• implement static methods having generics as parameters*

Implementing Non-static Features

• define what a class is in Java
• define what the this keyword means in Java
• explain how non-static attributes and methods differ from static attributes and methods
• use and draw UML diagrams of classes
• draw memory diagrams for classes
• define what a constructor is in Java
• define what a default constructor is in Java
• define what a copy constructor is in Java
• implement constructors for a class
• implement constructor chaining for a class
• define what an accessor method is
• define what a mutator method is
• implement accessor and mutator methods for a class
• define what the toString method is used for
• implement the toString method for a class
• define what the equals method is used for
• implement the equals method for a class
• define what the compareTo method is used for
• implement the compareTo method for a class
• write tests for non-static methods
• define what an immutable class is (and why they are useful)
• implement an immutable class
• define what a class invariant is (and why they are useful)
• describe when a class invariant must be true
• define what the hashCode method is used for
• implement the hashCode method for a class
• implement methods that use parameter validation
• add documentation to a class using Javadoc
• implement methods having interfaces as parameters
• implement methods having generics as parameters*

Mixing Static and Non-static Features

• implement a class that can count the number of objects created
• implement a class that stamps serial numbers on objects
• implement a class that uses the singleton pattern
• implement a class that enforces one instance per state

Implementing Aggregation and Composition

• define aggregation
• define composition
• use and draw UML diagrams for classes that use aggregation and composition
• draw memory diagrams for classes that use aggregation and composition
• explain the differences in constructors and methods between classes that use aggregation and classes that use composition
• implement classes that use aggregation
• implement classes that use composition
• contrast aliasing, shallow copying, and deep copying

Implementing Inheritance

• use and draw UML diagrams for classes that use inheritance
• draw memory diagrams for classes that use inheritance
• define what a superclass (or parent class) is
• define what a subclass (or child class) is
• state what features are inherited by subclasses
• define what the keyword extends means in Java
• define what the keyword super means in Java
• implement constructors for a subclass
• define what an overridden method is
• implement overridden methods for a subclass
• explain how preconditions, postconditions, and throws clauses behave in an inheritance hierarchy
• define what the final modifier means for methods
• define what the final modifier means for classes
• define what an abstract class is
• define what an abstract method is
• implement an abstract class
• define what an interface is in Java
• implement an interface

Implementing Graphical User Interfaces

• define what the model is in the model-view-controller (MVC) pattern
• define what the view is in the MVC pattern
• define what the controller is in the MVC pattern
• draw the UML diagram for the MVC pattern
• define what event-driven programming is
• implement a graphical user interface (GUI) using MVC

Recursion

• identify base cases for a recursive algorithm
• identify recursive cases for a recursive algorithm
• implement a recursive algorithm in Java to solve a problem
• derive a proof of correctness for a recursive algorithm
• derive a proof of termination for a recursive algorithm
• solve a recurrence relation*

Arrays and Data Structures

• define what an array is
• create and use arrays
• implement a List using an array
• implement an iterator for a class that models a collection
• implement a recursive data structure such as a linked list or tree*
• implement a stack*
• implement a queue*
• understand the basic operations on recursive data structures such as linked lists and binary trees*
• understand the basic operations on stacks and queues*

Course Text

There is no textbook for this course. Notes will be provided. For further reading, the textbook "Absolute Java" by Savitch is recommended. The book is available in the Steacie Library. The book "Java Pocket Guide" by Liguori and the book "Eclipse IDE Pocket Guide" by Burnette might be useful as well.

Evaluation

The final grade of the course will be based on the following items weighted as indicated:

Test 1	5%
Test 2	30%
Test 3	30%
Test 4	20%
Exam	15%

Grading: The final grade for the course is obtained by combining the scores of the tests and converting this total to a letter grade according to the following table.

≥ 90	≥ 80	≥ 75	≥ 70	≥ 65	≥ 60	≥ 55	≥ 50	≥ 40	< 40
A+	A	B+	B	C+	C	D+	D	E	F

Missed tests: Students with a documented reason for missing a test, such as illness, compasionate grounds, etc., will have the weight of the missed test shifted. For Test 1, the weight will be shifted to the exam. For all other tests, the weight will be shifted to a make up test held during the exam period. This make up test will cover all the material presented in the course.

Academic Honesty

During tests, students are expected to do their own work. Looking at someone else's work during the test, talking during the test, using aids not permitted (such as a phone) during the test, and impersonation are all examples of academically dishonest behaviour. Students are expected to read the Senate Policy on Academic Honesty.

Additional Information

Academic Integrity: There is an academic integrity website with comprehensive information about academic honesty and how to find resources at York to help improve students' research and writing skills, and cope with University life. Students are expected to review the materials on the Academic Integrity website.

Access/Disability: York University is committed to principles of respect, inclusion and equality of all persons with disabilities across campus. The University provides services for students with disabilities (including physical, medical, learning and psychiatric disabilities) needing accommodation related to teaching and evaluation methods/materials. These services are made available to students in all Faculties and programs at York University.

Students in need of these services are asked to register with disability services as early as possible to ensure that appropriate academic accommodation can be provided with advance notice. You are encouraged to schedule a time early in the term to meet with each professor to discuss your accommodation needs. Please note that registering with disabilities services and discussing your needs with your professors is necessary to avoid any impediment to receiving the necessary academic accommodations to meet your needs.

Additional information is available at the following websites:

• Counselling & Disability Services
• York Accessibility Hub

Religious Observance Accommodation: York University is committed to respecting the religious beliefs and practices of all members of the community, and making accommodations for observances of special significance to adherents. Should any of the dates specified in this syllabus for an in-class test or examination pose such a conflict for you, contact the course director within the first three weeks of class. Similarly, should an assignment to be completed in a lab, practicum placement, workshop, etc., scheduled later in the term pose such a conflict, contact the course director immediately. Please note that to arrange an alternative date or time for an examination scheduled in the formal examination periods (December and April/May), students must complete an Examination Accommodation Form, which can be obtained from Student Client Services, Student Services Centre or online.

Student Conduct in Academic Situations: Students and instructors are expected to maintain a professional relationship characterized by courtesy and mutual respect. Moreover, it is the responsibility of the instructor to maintain an appropriate academic atmosphere in the classroom and other academic settings, and the responsibility of the student to cooperate in that endeavour. Further, the instructor is the best person to decide, in the first instance, whether such an atmosphere is present in the class. The policy and procedures governing disruptive and/or harassing behaviour by students in academic situations is available online.