CSC 207 Spring 2023

Instructor: Dawn Nye
Office Hours: Noyce 2610 at TTh 12:00-1:50pm (or by request/whenever my door is open)
Mentor: Ellie Seehorn
Mentor Sessions: Sunday 2pm at Noyce 3815
Meeting Times: MWF 1:00-2:20pm at Noyce 3815
Textbook:
Core Java: Fundamentals Volume 1 (semi-required reference material)
Guide to Teaching Puzzle-Based Learning (optional)

Prior courses taught the principles of functional programming and imperative programming. In the latter, a common design pattern is to construct a data wrapper (such as a struct) around a collection of related values. An archetypal example of this is a node struct for a linked list, which contains its data as well as the next node in the list (and perhaps some additional bookkeeping information). Along with this data wrapper, there are a number of associated functions that use this imposed structure. We typically group the data wrapper and its basic functions together into a single file for organizational purposes. However, it would be awfully nice if there were a more formal way to package them as a single unit.

Enter object-oriented (OO) programming. The core design principle of OO programming is that data and its primitive functions should be encapsulated into a single object. Other functions may use this object to perform additional computation, but they need not know about its internal operations. To continue the above example, a linked list contains nodes, but from an outside perspective, one needs only to be able to access its contents by index. Manually keeping track of its nodes is unnecessary.

In this course, we first study the basics of OO programming. After this, we commence a formal study of data structure, that is typical ways that we group data and primitive functions together to perform computation. Along the way, we also investigate common OO design patters, or rather common ways of arranging our OO code to solve problems.


Order of Topics and Readings

Topic*Suggested Reading
Introductions
What is OO Programming?
Java BasicsChapter 1 (historical information)
Chapter 2 (setting up your IDE)
Chapter 3 (programming basics in Java)
ClassesChapter 4 Sections 1-7
DocumentationChapter 4 Section 9
Inheritance and PolymorphismChapter 5 Sections 1-2
Chapter 6 Sections 1-2
Generics (And Why Java Does It Wrong)Chapter 8
Inner ClassesChapter 6 Section 4
ExceptionsChapter 7 Sections 1-3
Anonymous Inner ClassesChapter 6 Section 4
Lambda ExpressionsChapter 6 Section 3
Stacks, Queues, and Deques
Trees
Self-Balancing Trees
Segment Trees
Axis-Aligned Bounding Box (AABB) Trees
Heaps
Priority Queues
Hash Tables
Dictionaries
Graphs
Graph Traversals
Path Finding
Sorting

* Some subject material may be omitted according to actual progress during class
† Supplemental readings beyond the scope of the textbook may appear at future dates


Learning Outcomes

  • Create multi-file programs with Java
  • Collaborate with one or more students in the creation of programs and the completion of labs
  • Apply OO design principles
    • Polymorphism
    • Inheritance and composition
    • Abstraction
    • Encapsulation
    • Generics
  • Use core abstract data structures to design solutions to programming tasks
    • Arrays
    • Lists
    • Stacks
    • Queues
    • Graphs
    • Hash tables
    • Maps
    • Heaps
  • Compare and contrast data structures and select the appropriate one for a given task
  • Implement and use core algorithms to design solutions to programming tasks
    • Sorting
    • Searching
    • Iteration
    • Traversal
  • Analyze runtime complexity of algorithms
  • Create effective unit tests (JUnit tests)
  • Effectively use exception handling to detect and handle runtime errors
  • Create documentation for Java programs using Javadoc