Comp201: Principles of Object-Oriented Programming I
Spring 2008 -- Exam 1 Need-To-Knows   

The following is a non-exhaustive list of topics, concepts and skills that will be covered in Exam 1. This list is subject to frequent changes, so check back often!

This list is in no particular order, nor does it indicate any sort of priority, unless otherwise noted.

1. Design Patterns:
   1. Union
   2. Strategy
   3. Composite
   4. Interpreter
   5. Singleton
2. Object-Oriented Programming components:
   1. Objects
   2. Classes
   3. Interfaces
   4. Access specifiers
      1. public
      2. private
      3. package
   5. Other specifiers
   1. static
   2. final
   3. abstract
   6. Objects vs. primitives
      1. values vs. references
      2. ineritance from Object vs. not an Object
3. Object and Class relationships
   1. Inheritance
      1. vs. Polymorphism
      2. overriding of methods
   2. Composition
      1. as communication pathways
      2. for creating more complex objects
   3. UML class diagrams to represent classes and their relationships.
      1. class => box with name at top and lines between name, fields and methods.
      2. methods => input types and names & output types usually shown.
      3. extends => solid line, closed arrowhead
      4. implements => dotted line, closed arrowhead
      5. public => '+;'
      6. private => '-'
      7. package => (no symbol)
      8. composition => solid line, open arrowhead w. optional open diamond at base
      9. abstract => italics
      10. static => underlined
4. Abstract representations
   1. of data structures
      1. as interfaces
      2. as abstract classes
   2. of behavior
      1. abstract behaviors
      2. as objects (strategies)
5. How to write code for
   1. a class
      1. with inheritance
      2. with private fields
      3. with a constructor that initializes fields
      4. with public methods
         1. that take multiple input parameters
         2. that has a return value
         3. that returns void
      5. that is a singleton
   2. a JUnit test class
      1. using assertEquals
      2. using assertTrue
6. Variant vs Invariant
   1. Definitions of each
   2. Why their separation is so important.
   3. Be able to identify the variant vs. invariant parts of a system.
7. List algorithms
   1. Recursion
   2. Interpreter design pattern
   3. Know how to write all the reverse accumulation algorithms in Lab 5. You are not responsible for forward accumulation for the this exam (next one, yes!).

Last Revised Thursday, 03-Jun-2010 09:50:26 CDT

©2008 Stephen Wong and Dung Nguyen