CMPS 134 Fall 2025
Preview for Test #1 (Oct. 1)

Among the things that you should know:

• Java is the programming language that we are using in this course as a vehicle to learn about computer programming.
• jGrasp is the "integrated development environment" (IDE) that we are using (in lectures and labs) to aid us in developing and testing Java code.
• Among the kinds of errors that can be present in computer programs are syntax, logical, and run-time.
  • Syntax errors, which are detected by the Java compiler, are analogous to errors in English grammar. The presence of a syntax error renders a program "invalid".
  • A run-time error occurs when a program's execution is aborted due to an unexpected condition occurring. Examples:
    • division by zero
    • invalid input is provided (such as when the program expects an integer input and instead receives a character string containing letters or a numeral including a decimal point)
    • A method call is made on a reference variable having value null (e.g., str.charAt(k) when str is a variable of type String but no value has yet been assigned to it)
    In Java, a run-time error results in an exception being thrown.
  • A logical error, typically due to a programmer making a mental mistake, results in a program that, when executed, behaves in a way that was not intended. For example, the program could produce output that is not correct with respect to its input. Run-time errors are often the result of an underlying logical error.
• Comments appear in programs to provide useful information to human readers. Among the kinds of information that comments might convey are
  • the program's intended behavior/purpose
  • the author(s) (i.e., who developed the code)
  • the date(s) on which the program was written or modified
  • an explanation of the reasoning that justifies certain code segments being written as they were
• Java has eight primitive data types. Among them are the four that are most imporant in this course: int (for representing integers (e.g., 13)), double (for representing real numbers (e.g., 27.35)), boolean (for representing true and false), and char (for representing character values (e.g., '$', 'A', '8')).
• How to evaluate arithmetic and boolean expressions involving literals (e.g., 32, 1.52, true), variables, arithmetic operators (+, -, *, /, %), relational operators (<, <=, >, >=, ==, !=), and boolean operators (!, &&, ||).

  Examples (where k, m, x, etc., are variables whose data types and values would be indicated on the test):

  5 + k * 8	k / 4	(k+3) % m	5 * 2.5
  (char)('A' + 4)	(double)(k - 2)	(3 * k) / m * x	Math.abs(k)
  x <= y + 5.8	k != N && j > 0	!(k == N || j == 0)	Math.pow(Math.max(x,y),3))

• How to evaluate expressions involving calls to methods in the java.lang.String class. Examples (where s and t are variables of type String and k and m are of type int, all having values indicated on the test):

  s.charAt(k+2)	s.substring(k,m)	(s+t).length()
  s + t.substring(k)	s.indexOf('A')	s.substring(s.indexOf(','), s.lastIndexOf(' '))

• You should be able to "trace execution" of a Java program involving variable declarations, assignment statements, methods, calls to methods (possibly with parameters being passed and/or values being returned by the method), for-loops, and String objects. For example, you may be given a Java program and asked to show what output it would produce if it were executed.
• 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 a simple computational task that can be accomplished using assignment statements, arithmetic and/or boolean expressions, calls to methods in the java.lang.Math class, simple String processing, and possibly a for-loop, you should be able to write Java code (perhaps a method body) that performs it. Examples:
  • Given a number of inches, express it in terms of feet and inches.
  • Given integers low and high, print each even integer in the range [low..high].
  • Given integers low and high, print the sum of the odd integers in the range [low..high].
  • Given integers low and high, print the sum of the square roots of the integers in the range [low..high].
  • "Draw" a figure similar to ones drawn by the DrawFiguresWithLoops application program.
  • Given a calendar date in MM/DD/YYYY format (e.g., "05/13/2021", produce the same date in YYYY-MM-DD format (e.g., "2021-05-13").