Exam 1

The focus of Exam 1 is on Java programming; evaluating expressions, knowing type of an expression, tracing through code, problem solving and writing code (adding methods to classes, writing code fragments, and writing whole classes).
You may want review Some Tips for Taking CS21 Exams.

Unix will never be an exam topic; I will not ask questions about Unix commands, Unix file system, vim, etc.

Exam 1 Topics

The topics that will be covered on the exam are:
storage locations for specific types of data (type is important)
need to be declared 
need to be initialized before used
	assign a variable an initial value
	know how to read in input value: 
		Scanner reader = new Scanner(System.in);	
		int x = reader.nextInt();  
		// or .nextFloat(), .nextDouble(), .nextLine(), 

	know how to assign an object reference a value:
	String str1 = new String("hello");
	String str2 = null;
	str2 = str1; 	// str1 and str2 point to the same String object

method calls
	System.out.println("blah " + 3);
	x = reader.nextInt();

assignment statements 
	var = value of expression;
	the expression, rhs, can contain a method call
	type is important!

evaluating expressions:
know how to evalute and write arithmetic and boolean expressions
know the difference between int and float or double operations
know the arithmetic  operators
know the precedence rules 
boolean expressions (know the logical and relational operators)

know how to use and why they are used in programs.
know how, and where, to define them:

  public class TestClass {

	public final float MAX = 3.6;
	public final int NROWS = 4;

	public static void main(String[] args) { ...

loops and conditional stmts
know how to write for loop, while loop, and if-else stmts, and know
how to trace through a switch stmt (I won't ask you to write one)
know how for and while loop are equivalent (can translate one to the other)
nested loops

Using objects:

   Foo f;  // f is a reference to a Foo object

   f = null;  // null is a special reference value (refers to nothing)

   if(f == null) { ... // we can test f's value to see if it is null

new: use new to create a new Foo object, new calls one of Foo's constructors
   f = new Foo(x, y);

use dot to access the Foo object's public data members or methods 

   String s = f.getName();

Know these classes:  String, Math, Random
	I'll give you a list of the methods from these classes (the 
	method signatures) , but you should know what the methods do 
	and how to call them 

Static methods:  associated with the class not the object
   double result = Math.sqrt(3.5);

Writing your own classes
A class is type definition for set of related objects

need to define (1) data part and (2) services part (methods)

public class MyClass {

  data members should be private

  private int _age;
  private String _name;
  private String _addr;

+ implement services of objects
+ important for modular code design
+ code re-use
+ the black box idea:  take input, perform a computation, return a result 

There are different types:
(1) Constructors

   public MyClass(param list) { ... } 

(2) Accessors and Modifiers (provide access to private data members)

(3) Other methods that implement a service provided by an object
	public String toString() { ...
	public int compareTo(MyClass mclassref) { ...
	// and others

(4) Static methods are associated with the class not with individual objs
    if method doesn't use object state, then it could be static

   // main is an example of a static method,
   public static void main(String[] args) { 

method definition: 
public return_type  MethodName(par1_type par1name, par2_type par2name, ...) {

	local variable declarations

	return (expression of type return_type);

method call semantics:  
   how arguments are passed to parameters
   stack allocation/deallocation as call/return from methods
   scope rules: when a variable name has meaning 
   how method returns a value to its caller
   	void methods do not return a value
   method can call method can call method...
      know what happens with the stack and with scope rules 

   * ordered, homogeneous collection of data
   * arrays are objects, but they have a special syntax for accessing bucket
     values and for creating
   * actual size (total capacity) vs effective size (amt. currently using)
   * declaring and accessing array buckets:

	float[] farray;
	farray = new float[20];   // create a new float array object with 20 buckets
	                          // each bucket stores a float value 

	farray[4] = 6.3;	 // index must be an int

	farray.length	         // data member length, stores array's actual size

   * for loop index often used to access all array buckets in some way

   * passing arrays to methods: like passing any other object to a method
			        should always pass array's effective size

	public int foo(int array[], int size) { ...  }

	call: int[] array1, array2; 
	      // initialize both in some way

	      int x = foo(array1, 5);
	      int x = foo(array2, 5);

You should be able to:

  1. write code given an English description of what your code should do: write methods, write whole programs, and/or write code fragments (less than a whole methods)
  2. evaluate expressions and know the type that they evaluate to
  3. Trace through a Java program given the code and show the contents of the Stack, and of Object memory, and show the program's output
  4. use Java class library class given a list of the methods they provide (I'll give you API documentation without the description of what the methods do)