The first test for this course takes place in class on Monday, February 20. It will cover material from classes and labs as well as from assigned readings. The test will be four pages long. It can include definitions and short answer questions; longer essay-type questions; questions that ask you to write code segments or a complete program; and questions that ask you to determine the purpose or the output of a given code segment. For definitions, you might be asked about basic terms such as CPU, main memeory, algorithm, infinite loop, variable, type, subroutine, syntax, semantics, and array.
The test covers parts but not all of Chapters 1, 2, and 3 from the textbook. From Chapter 1, we covered only some basic concepts, from Sections 1.1, 1.3, and 1.4. We covered most of Chapter 2 except for Section 2.6, programming environments, and a few specific topics. From Chapter 3, we covered Section 3.1 through 3.5 and 3.8 (but not 3.8.5, multidimensional arrays). We might cover 3.6 and 3.7 before the test, but they will not be on the test. We omitted all material in Chapters 2 and 3 on enum, Scanner and using TextIO with files. You are also responsible for material from the labs. In particular, you should be familiar with the drawing commands that were used in the labs.
You are not responsible for every detail of the reading. In particular, you are not responsible for memorizing every subroutine defined in Math, TextIO, and String; see the lists, below, of subroutines for which you are responsible. You will not be asked about the switch statement, the do..while statement, the try..catch statement, the continue statement, or labeled break statements. You will not be asked about specific examples,such as the 3N+1 problem or interest rate computations, that are covered in the text. There will be no questions on Linux or the command-line environment, except possibly for the javac and java commands and the general process of editing, compiling, and running a program.
Here is a list of some of the things that you should know about:
CPU
computer programs
machine language
high-level programming language
compiler
Java bytecode
Java Virtual Machine
how to compile and run a Java program: The javac and java commands
style rules and why they are important
style rules for variable names and class names
formatting and indentation of programs
comments using //
comments using /* ... */
the basic structure of a Java program (You should have it memorized by now!!!):
public class <program-name> {
public static void main(String[] args) {
<statements>
}
}
syntax and semantics
syntax errors (found by compiler) vs. semantic errors (seen at run time)
identifiers
compound names (with ".") such as System.out.print or str.equals
variables
data types
Java's primitive types: int, double, char, boolean
the String type
literals
Java literals of various types (numeric, char, String, boolean)
special characters in char and String literals, such as '\n' and '\t'
the basic idea of binary numbers (strings of 0's and 1's)
assignment statements
type compatibility rules for assignment statements
declaring variables
subroutines, and "calling" a subroutine such as System.out.print or g.drawRect
parameters in subroutines, such as the x in System.out.println(x)
functions: subroutines that "return a value"
important functions in the Math class:
Math.random(), Math.sqrt(x), Math.pow(x,y)
important functions in any String str:
str.length(), str.charAt(i), str.indexOf(ch), str.equals(str2), str.equalsIngoreCase()
comparing Strings with str.equals(str2) instead of str == str2
System.out.print(x), System.out.println(x), and System.out.print()
formatted output with System.out.printf(formatString, v1 v2, ...)
important format specifiers for use in the formatString of printf:
for example: %s %d %4d %1.2f
getting input from the user
TextIO; important TextIO input functions:
TextIO.getln(), TextIO.getlnInt(), TextIO.getlnDouble()
expressions
operators
precedence of operators and using parentheses to control order of evaluation
important operators:
+ - * / % == < > != <= >= && || ! ++ -- += *=
type-casting, especially using (int) and (double) for type-casting numbers
making random integers: (int)( m * Math.random() + n )
how the / and % operators work for integers; using n % d to test if d evenly divides n
using the + operator with a String
statements
control structures
the empty statement: ;
block statement: { }
while statement: while ( condition ) { statements }
for statement: for ( initialize ; condition ; update ) { statements }
simple if statement: if ( condition ) { statements }
if..else statement: if ( condition ) { statements } else { statements }
using if..else if...
using while(true) loops
using break in a loop
processing the characters in a String using a for loop
nested for loops
infinite loop
algorithm (the most basic object of study in computer science!)
pseudocode
bugs and debugging
arrays
element of an array; index of an element in an array
array types such as int[], double[], and String[]
length of an array: A.length, list.length
creating an array with the new operator, such as: A = new int[10];
accessing individual elements in an array using notations like: A[7], list[i]
processing the elements of an array using a for loop
the paintComponent() method in GUI programs
pixels
the xy coordinate system that is used for drawing
important subroutines in a Graphics object g (for use in paintComponent):
g.setColor(c), g.drawRect(x,y,w,h), g.fillRect(x,y,w,h),
g.fillOval(x,y,w,h), g.drawOval(x,y,w,h), g.drawLine(x1,y1,x2,y2),
g.drawString(str,x,y)
basic color values: Color.RED, Color.GREEN, Color.BLUE, Color.WHITE, Color.BLACK, etc.