CPSC 120 -- Test #3 Review Topics

• Loops (Sections 4.5 (while - this was on the last test but you still need to know how to do them!), 4.7 (do...while), 4.8 (for loops), Sections 7.1 - 7.3 (using loops to process arrays), Labs 7 - 11, 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 - this includes showing values of variables as it executes, showing what it prints, or giving a verbal high-level description (such as finds the product of the multiples of 3 from 1 to n).
  • 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 especially using a for statement) and a sentinel controlled loop (and how to write one).
  • Be able to perform common looping subtasks -- summing, counting, finding averages, finding products, 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 use a loop to ensure valid input (keep making the user enter values until the value is in the correct range). Be able to use a loop to go through an array and "do something" to each element.
  • Be able to write and understand complex loops containing method calls, conditions, and other loops (nested loops).

• Objects and Classes (Sections 3.1, 5.1 - 5.8, Labs 3 and 8 - 11, class notes and handouts - All Self-Review Questions, except 5.5 on pages 227 and 228 are good review.)
  • Understand the difference between objects and primitive values, including the difference in how they are stored (directly vs. references).
  • Be able to create (instantiate) an object given the type signature of one or more constructors of the appropriate class.
  • Be able to use an object appropriately given the type signatures and reasonable documentation for its methods.
  • Understand the meaning of the public and private modifiers and when each is appropriate.
  • Understand the meaning of encapsulation (related to the idea that an object should be self-governing) and how visibility modifiers are used to enforce it (specifically understand what parts of the class should be private and what should be public and how doing that enforces encapsulation).
  • Understand the concepts of attributes and behaviors (or operations) of objects and how these relate to instance variables and methods in the classes we write.
  • Understand the difference between instance data (variables) and local data (variables).
  • Be able to write a class given a description of the capabilities required of it.
  • Know what an alias is and what garbage is! (Section 3.1)
  • 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.
  • Know what the reserved word this is.

• Methods (Chapter 5 but especially sections 5.4, Labs 3, and 8 - 11, class notes and handouts)
  • Be able to write a method to perform a given task.
  • Know what a constructor is and how a constructor differs from other methods (when a constructor is executed and other differences). Be able to write constructors.
  • Understand the role of the toString method - what it does and how it is used implicitly when an object is included in a print statement. Understand what happens if you try to print an object for a class that does not have a toString method.
  • Understand all components of a method's signature -- public/private, static/instance, return type, method name, formal parameters.
  • 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.
  • Understand the difference between formal and actual parameters.
  • Understand the scope of identifiers - where formal parameters can be referenced, where local variables can be referenced, where instance variables can be referenced. (pp. 179, 196-198)
  • 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 5.11 on page 227)
  • Understand what it means to say a method is overloaded. Be able to explain how overloaded methods can be distinguished from each other.

• Arrays (Chapter 7, Sections 7.1 - 7.3)
  • Know how to declare and instantitate an array.
  • Be able to write code to go through an array and process each element (for example, read elements into an array, print elements of the array that meet some condition, count elements that meet some condition, sum elements, find averages, find maximum or minimum, compare elements - lots of possibilities.
  • Know how to use the relationship between the "values" of data of type char and ints; be able to work with this relationship and casting to go back and forth beween ints and chars; be able to use this to index into an array that is indexed by the letters of the alphabet (that is, each entry in the array holds some information about a letter in the alphabet).
  • Be able to work with arrays of objects.
  • Understand the problems in working with arrays (index out of bounds) and arrays of objects (null pointer exceptions); be able to detect these errors in code; be able to write code that avoids these errors.