CMPS 144 Spring 2025
Feb. 26 test preview

• Given a Java program, you should be able to identify pieces of it that are examples of the following elements of the Java language:
  • key/reserved word (e.g., class, int, public)
  • comment (e.g., /* This program does nothing. */)
  • assignment statement (e.g., x = 3.5 or grossPay = hoursWorked * hourlyWage)
  • numeric literal (e.g., 3.5 in line above)
  • String literal (e.g., "Hello, World!")
  • operator (arithmetic, relational, boolean)
    • arithmetic operator (e.g., +, *)
    • relational operator (e.g., ==, <=)
    • boolean operator (e.g., &&, ||)
    • String operator: + (concatenation)
  • expression
    • arithmetic (e.g., 2*k + 5)
    • boolean (e.g., k <= 5)
    • String (e.g. "Hello, " + name)
  • variable declaration (e.g., int numHours)
  • method call (e.g., drawRightTriangle(k+1))
  • actual parameter/argument (e.g., the k+1 in line above)
  • method heading (e.g., public static void drawRightTriangle(int size))
  • formal parameter/argument declaration (e.g., int size in line above)
  • class heading (e.g., public class Stupid)
• Given some relatively simple computational problem (e.g., possibly involving an array) and a loop invariant to guide you, develop code to solve the problem in a manner consistent with the given loop invariant. (Recall the lectures pertaining to 2-color and 3-color partitioning, as well as Lab #5, in which you implemented loops that conformed to specified loop invariants.)
• Given an array whose elements are in ascending order (from least to greatest) and a search key, trace execution of the binary search algorithm, which finds the lowest-numbered location in the array containing a value greater than or equal to the search key. (Tracing execution means showing the values of relevant variables at particular "moments in time" (namely, initially and at the end of each loop iteration).)
• Given a relatively simple abstraction (e.g., a pair of dice or a line segment), develop a Java class to implement it. If other classes are provided as potential building blocks (e.g., SixSidedDie, PointOnPlane), use them in that implementation. (Recall the TimeOfDay class from Lab #1 and ComplexNumber from the programming assignments.)
• Given a relatively simple Java class that lacks some desired functionality, develop a child class that provides that functionality.

  Recall the classes from Lab #2: Temperature and its child Temperature2, TimeOfDay and its child TimeOfDay12Or24, and SixSidedDie and its child SixSidedDieWithCounts.

  Also recall from lecture the (Tossable)Coin class and its descendants, BiasedCoin and BiasedCoinWithCounts. Aspects of the Counter class hierarchy were covered in lecture and Lab #4.

• Given an abstract Java class that "expects" its children to supply the implementation of one or more of its abstract method(s) (i.e., methods whose bodies are omitted), develop such a child class. (Recall the classes of Lab #4, including BoundedCounter, StringSorter, and FilterOfInt, and their children.)
• Given a class hierarchy (e.g., Counter and its descendants in Lab #4) and a program that makes use of objects from classes in that hierarchy, be able to trace execution of that program and report its results. (In particular, that would involve understanding, with respect to a method call obj.doSomething(), which version of the doSomething)() method actually gets called (among the possibly multiple versions found in classes in the hierarchy).