CPSC 120 -- Test #3 Review Topics
- Loops (Sections 5.5 (while), 5.7 (do...while),
5.8 (for - omit the part about iterators and for loops),
Labs 7 - 10, class notes)
- Know the three basic loop structures and the differences
- 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).
- Know what an alias is and what garbage is!
- Be able to create an object given the type signature of one or more
be able to use an object appropriately given the type signatures and
reasonable documentation for its methods.
- 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.
- Understand the difference between static and instance methods, how each
is accessed, and when each should be used.
- Be able to write a class given a description of the capabilities required
- Understand the meaning of the public and private modifiers
and when each is appropriate.
- Understand the meaning of encapsulation.
- Be able to describe the steps in software development.
- 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.
- Methods (Sections 4.3, 6.7 - 6.8, Labs 5 - 10, class notes
- Be able to write a method to perform a given task.
- 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,
and how both primitive values and objects are passed to a method.
- Be able to trace method calls to show how parameter passing works and
how local variables are handled.
- Understand how a method can be overloaded, and be able to
write and use overloaded methods.
- Be able to write methods (including main) that call other methods as