Exam 2 Topics
CS141: Introduction to Programming, Fall 2013

General Comments and Recommendations

• The exam will be focused on Chapters 5-8 of the text (up to and including classes and objects). However, since the material is cumulative, you are still expected to remember the earlier material.
• The exam will be 1 hour long. It will be closed book. Electronic devices, of any kind, will not be allowed.
• It is strongly recommended that students:
  • Re-read the text
  • Do the self-check exercises in each chapter (answers are in the text)
  • Review the reading quizzes
  • Review the programming code-completion and programming exercises.
• Practice Problems which could appear on the exam:
  • Basic Method Problems (pdf)
  • Scope (pdf)
  • Pass by Value vs Pass by Reference (pdf)
  • Practice Array problems
  • Basic Class & Object Problems (pdf)
  • Old exams.

Chapter 5: Methods

Vocabulary

method (function, member function, procedure) black box modularization stepwise refinement (revisited) reusability return type, return value

(formal) parameter variable argument (actual parameter) parameter passing variable scope: local, global tracing code stub recursive methods

Common expressions are:

"call a method" or "call a function"
"return a value"
"pass a value as a parameter"

Topics

• What are methods and why do we want them? E.g. Math.round, rolling a die.
• Why use methods?
  • reusability
  • modularity and testing
  • structure and readability
• Components of a Method Declaration See Basic Method Problems (pdf)
  • header (first line, aka the method signature) - contains the return type, method name, parameter list
  • method body
  • If the return type is not void, the method body must contain a return statement
  • Terminology:
    • declare or write a method
    • call a method
    • arguments (actual parameters) vs formal parameters
    • passing in a parameter (argument)
• Tracing the code - stepping through the code line-by-line. Do you understand the order the statements are executed?
• Scope - see Scope (pdf) practice that we did in class.
• Writing code using stepwise refinement - methods make this easy to do.

Chapter 6: Arrays and ArrayLists

Vocabulary

array (1D, 2D, multi-dimensional) Declaring an array Initializing an array Enhanced loop Arrays class Pass by value Pass by reference

ArrayList Creating and declaring an ArrayList Diamond syntax Auto-boxing

Topics

• What is an array? Why do we need them?
• Declaring 1-dimensional arrays. (Here are some old notes on 1D Arrays.)
• See Practice Array problems
• Accessing array elements
• Initializing arrays
  • one at a time.
  • Using for-loop
  • Using brackets
  • Using Arrays class.
• Printing or Using arrays
  • one at a time.
  • Using for-loop
  • Using an enhanced loop
  • Using Arrays class.
• Swapping elements in an array.
• Copying arrays.
• Partially filled arrays
• Pass by Value vs Pass by Reference (pdf)
• Arrays as return values and parameters in methods.
• ArrayLists: declaring, adding/removing elements, look at method list, copying, wrappers for primitive types
• Declaring and using multi-dimensional arrays. (Here are some old notes on 2D Arrays.)

Chapter 7: Input/Output and Exception Handling

You are required to know the vocabulary but you will not be asked to write code related to this topic.

Vocabulary

File Ascii (text) file vs binary file Opening a file Closing a file White space

Exception Throwing an Exception Catching an Exception try-catch Delimiter

Chapter 8: Objects and Classes

Vocabulary

Object-oriented programming Encapsulation Public interface Private implementation Class Object (instance of class) Member (instance) variable Instance method Constructor The keyword: new Object reference Null reference

Mutator method (setter) Accessor method (getter) toString method Sending a message Overloading Class (static) method Class (static) variables Modifier (public, private) this reference Unit testing

Topics

• Motivation of Classes and Objects: Organizing and structuring code to promote reusability, readability, and correctness
• Encapsulation: Separating the public interface from the private (hidden) implementation
• Class vs Object Analogies: script vs actor, cookie recipe vs the cookie itself
• Examples: Die class, Card class
• See Basic Class & Object Problems (pdf)
• Components of a Class (also see categories):
  • Data:
    • Member (instance) variables (one for each object)
    • Class (static) variables (one for all objects)
  • Actions:
    • Public interface (public methods)
      • Common for most classes:
        • Access to data: Mutators and Accessors (also called getters and setters)
        • Handy Utilities: toString
        • Creation: Constructor
      • Public methods for a specific class (e.g. In the Die class, one might have a roll() method)
    • Private Implementation:
      • Data hiding: data is usually private. Use accessors & mutators instead.
      • private methods - not accesible from outside of the class.
• Working with Objects
  • Creating an object using the keyword new and a constructor
  • Object references
  • Objects as method parameters and return types: Pass by Reference (not Pass by Value)
    *** Recall discussion with arrays
  • The null keyword and Null Pointer Exceptions
  • Testing your code.
  • Sending an object a message using the public interface. (calling a method)
  • Self referencing using the keyword this
• Overloading: Methods with he same name but different signatures (headers)
• Class (static) methods and variables:
  • class vaiables - one per class
  • instance variables - one per object
  • class methods can only access class variables and other class methods
  • instance methods can access all other variables and methods (class or instance)
• You should know how to draw a Class Diagram.
• You should know how to draw an Object Diagram (i.e. what objects and references are created or destroyed as a program executes. We did two examples in class:
  • Recall the Object diagrams we did in lecture based on the rough Class Diagram. The object diagrams are posted on WISE in the resource section or can be found here.
  • Recall the in-class exercise. Solution may be found here: Lines 1-7 and Lines 8-16