CPSC 120 -- Test #3 Review Topics

• Loops (Sections 5.5 (while), 5.7 (do...while), 5.8 (for - omit section "Iterators and for Loops"), Labs 7 - 10, class notes, quizzes)
  • Know the three basic loop structures and the differences among them; given a loop of one type (for example, while) be able to write an equivalent loop of another type.
  • Be able to trace a loop to determine what it does.
  • Be able to write loops -- be able to correctly control the loop (write the appropriate boolean expression for the loop control condition, initialize any variables in that expression (loop control variables) before the loop, update those variables correctly inside the loop).
  • Know what is meant by a count-controlled loop (and how to write one) and a sentinel controlled loop (and how to write one).
  • Be able to perform common looping subtasks -- summing, counting, finding averages, finding max and min values. Be able to use a loop to go through a string character by character and do something such as count a particular type of character or find the first character after a blank.
  • Be able to write and understand complex loops containing method calls, conditions, and other loops (nested loops).

• Objects and Classes (Sections 3.1, 4.0-4.4, 6.1-6.4, 6.9, Labs 5 - 10, class notes and handouts)
  • Understand the difference between objects and primitive values, including the difference in how they are stored (directly vs. references). (Section 3.1)
  • Know what an alias is and what garbage is! (Section 3.1)
  • Be able to create (instantiate) an object given the type signature of one or more constructors and be able to use an object appropriately given the type signatures and reasonable documentation for its methods. (Chapters 3, 4, 5, and 6!!!)
  • Understand the difference between static and instance variables, and when each should be used. Understand why we often make constants in a class public and static and how a client program can access them. (Section 6.3)
  • Understand the difference between static and instance methods, how each is accessed, and when each should be used. (Section 3.6, the Math class, Self Review Question SR 4.11 on page 201, Section 6.3)
  • Be able to write a class given a description of the capabilities required of it. (Section 4.4 and 6.7)
  • Understand the meaning of the public and private modifiers and when each is appropriate.
  • Understand the meaning of encapsulation. (Section 4.3)
  • Be able to describe the steps in software development. (Section 6.1)
  • Know the basic strategies for determining objects and classes and for determining responsibilities (deciding which class does each task). Be able to apply these strategies. (Section 6.2)

• Methods (Sections 4.3, 4.4, 6.7 - 6.8, Labs 5 - 10, class notes and handouts)
  • Be able to write a method to perform a given task. (Section 4.4 & 6.7)
  • Understand all components of a method's signature -- public/private, static/instance, return type, method name, formal parameters. (Section 4.4)
  • Understand what it means for a method to return a value, and be able to both write and use such methods. In particular, understand the difference between a method that has void return type and one that returns a value. (Section 4.4 & 6.7)
  • Understand the difference between formal and actual parameters, and how both primitive values and objects are passed to a method. (Section 4.4 & 6.7)
  • Understand the scope of identifiers - where formal parameters can be referenced, where local variables can be referenced, where instance variables can be referenced. (pp. 166-167, 175-176)
  • Be able to trace method calls to show how parameter passing works and how local variables are handled. (Section 6.7 & handouts)
  • Understand how a method can be overloaded, and be able to write and use overloaded methods. (Section 6.8)
  • Be able to write methods (including main) that call other methods as appropriate. (Section 6.7 & labs)