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) - plus "Reading Text Files" part of
the section 4.6 on "Iterators",
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
- 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.
- 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
- 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.
- Be able to describe some of the issues in designing an object
oriented program - in deciding what classes to write and which classes
have which responsibilities.
- Methods (Chapter 5 but especially sections 5.4, 5.7,
Labs 3, and 8 - 11, class notes
- 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
and how both primitive values and objects are passed to a method.
Be able to trace the execution of a program to show how
parameters are passed.
- 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.