CS100J, Fall 2003   Preparing for Prelim 1: Monday, 29 Sept., 7:30—9:00PM

This handout explains what you have to know for the first prelim.

Terms and their meaning
Below, we summarize the terms you should know. You should be able to state the definition of a term like “assignment statement” clearly and precisely. For a Java construct, you should know its syntax. For a Java statement, you should know how to execute it.
• Expressions: Types int, double, boolean, char (their ranges and basic operations). Casting between types. Narrower type, wider type.
* Methods: Two kinds of methods: procedure, function. Syntax of a method definition. Parameter of a method. Local variable of a method. Scope of a parameter and a local variable. Be able to write a simple method.
• Method calls: How to call each kind of method. Argument of a method call. Restrictions on arguments based on the type of the corresponding parameter. Frame for a method call
• Variables. variable, declaration of a variable, assignment statement.
• If-statement and if-else statement. What their syntax is and how they are executed. If-condition.
• Block. What its syntax is and how it is executed.
• Classes. What is a class? Class definition. Instance (folder, or object) of a class. The name of a folder. Components: fields and methods. Static and non-static components of a class (where do they go?). What this means. The new-expression and what it is used for. You should be able evaluate a new-expression by hand, drawing the new folder, filling in the initial values, and yielding the name of the new folder.
• Subclasses.How to define a subclass. Inheritance and overriding. Casting with class-types. Narrower and wider class types. You should be able to draw a folder of a class or subclass, given the class definition.
Key concepts
These notes contain short definitions of the basic entities that make up a Java program, along with a description of the Java syntax for them and examples of them. Memorize these definitions. You should know them backward and forward by now, for they form the backbone of whatever we do from now on.
On a test, you should be able to write such definitions and examples. What you write must be precise and clear.
Class: A file drawer: contains static components and folders (instances, objects) of that class.
Class definition: a “model”, form, or blueprint for the objects (or instances) of the class; a class defines the components of each object of the class. All folders of the class have the same components. Analogy: a blueprint for a house is a design for a house, many houses (objects) can be built from the same blueprint, but they may differ in color of rooms, wallpaper, etc.
Java syntax:   public class <class name> {
   		             		declaration of fields and methods 
                      	     }
Variable: A named box that can contain a value of some type. For a type like int, the value is an integer. For a class-type, the value is the name of (or reference to) an instance of the class —the name that appears on the folder.
Declaration of a variable: a definition of the name of the variable and the type of value it can contain.
Java syntax:   <class or type name> <identifier> ;
Examples of variable declarations:
A variable x that can contain an integer:   int x;
A variable s that can contain the name of an object of class String: String s;
A variable c that can contain a boolean value (true or false): boolean b;
Method: A parameterized sequence of statements, whose execution performs some task. We study (so far) two kinds of methods: procedures and functions.
A method should be accompanied by a comment that says what the method does. This is the specification of the method. The comment has to be precise and clear. A potential user of the method should be able to look only at the comment and the list of parameters to know how to call the method; they should not have to look at the body of the method.
Example. When you want to bake a cake, you look at the title of a recipe, a short description, and the list of ingredients to determine whether you want to use that recipe —not the list of instructions to bake it.
A procedure is a method that performs some task (and doesn’t return a value)
Java syntax:
		/** Comment that explains what the method does */
		public void <method name> (<parameters>) {
	        Sequence of statements to execute
     		}
Example:
		/** Raise the salary by n dollars if the salary is < $20000 */
		public void raiseSal(double n) {
	 	    if (salary < 20000)
		         salary= salary + n;
		}
Example procedure call:
		raiseSal(20*y);
A function is a method that performs some task and returns a value. Instead of keyword void, the type of the returned value is used. Statement return <value>; is used to terminate execution of a function call and return <value>.
Java syntax:
		/** Comment that explains what the function does. It should include something like “= …” to
            	describe what the function value is. */
		public void <method name> ( <parameters> ) {
		     Sequence of statements to execute
}
Example:
		/** Yield the maximum of x and y */
		public int max (int x, int y) {
	 	    if (x>= y) return x;
		        return y;
		}
Example of a function call of max (within some statement):
		z= 1 + max(x,y);
Execution of an assignment statement stores a value in a variable.
Java syntax: <variable name> =   <expression> ;
Restriction: The type of the expression cannot be narrower than the type of the <variable name
Examples:
		b= 2+c;
		s= “Cardie” + “  ” + yearHired”;
Please, always put no blanks before = and one blank after =, to make it look unsymmetric and remind you that it is not an equality test but an assignment.
A block is used to unify a sequence of statement into a single statement.
Java syntax:  { sequence of statements }
Example:
		Here is a sequence of two statements:
			a= 10;
			if  (a < c) then
			     a= c;
		Here is a single statement, which is a block
			{  a= 10;
			    if  (a < c) then
			         a= c;
			}
Execution of a conditional statement allows a choice of execution.
Java syntax:
		if   (  <boolean expression>  )
			<statement>
or
		if   (  <boolean expression>  )
		        <statement 1>
		else <statement 2>
The first form is executed as follows: if <boolean expression> is true, then execute <statement>
The second form is executed as follows: if <boolean expression> is true, then execute <statement 1>;
if the <boolean expression is false, then execute <statement 2>.
A subclass B (say) is a class that extends another class A (say). This means that an instance of B has all the fields and methods that an instance of A has, in addition to the ones declared in B.
Java syntax:
		public class <class name> extends <class name> {
	  	 declarations of fields and methods
      		}
Access modifiers. Suppose d is an instance of Employee, where class Employee is declared as:
	public class Employee {
		   <access modifier> int x;
		   …
		   }
If the <access modifier> is: public, then field d.x can be referenced anywhere that d can be referenced.
If private, then field d.x can be referenced anywhere within class Employee that d can be referenced
kinds of variables: local variables, parameters, and fields (non-static)
public class Class1	{
public int x;                
	public int y;                                         //  x is a field of instance variable. It appears in every folder
public voidClass1 (int z)                    // z is a parameter.
			{z= z; y= 2*z;}
// Set y to the maximum of p and –p
public void sety(int p) {                    // p  is a parameter
    int x;                                              // x is a local variable of method sety. It cannot be used
    x= p;                                       // outside the method. It is local to the method.
    if (p > –p)
	    x= –p;
	    y= p;
    } 
The scope of a name is the set of places in which it can be referenced.
A variable can be declared only once within a method. Such a variable is sometimes called a local variable (of the method). 
The scope of a local variable of a method is the sequence of statements following it.
Example:
 	/** specification of method */
public test(int p) {
		y= p;
		int x;              // The scope of x starts at the next statement and goes
		x= p;              // to the end of the block in which the declaration of x appears
		if (p > –p) 
		    x= –p;
		y= p;
} 
The scope of a parameter of a method is the method body. 
Example:
 	// ...
public test(int p) {                        // The scope of parameter p is the method body
	if (y= p); {
		int x;                // The scope of x starts at the next statement and
		x= p;                 // goes until the end of the block in which the declaration
		if (p > –p)        // of x appears. It does not include the last statement y= p.
	    		x= –p;
		}
	y= p;
} 
The scope of a field of a class consists of:
(1) the bodies of all methods declared in the class and
(2) all declarations of fields that follow the declaration of the field.
Example:
public class Text  {               x
	int x= 5;
	int y= x+15;
	public void test(int p) {
		if (x= p); {
			int x= 35;                         x
			x= p;
			if (p > –p) 
	    			x= –p;
		}
	x= p;
	} 
}

Sample questions
Below, we give some sample questions. Note that you may be asked to write a small procedure or function, using assignments, if-statements, blocks, and return statements. Two sample questions of this nature appear at the end of the sample questions.
1. a) When do you use "=" and "==" 
    b) what is the difference between 'c' and "c"
   c)  if b == true and c =="true" what is the type of the variables b and c?
   d) What is the difference between a method declared with keyword static and one without the keyword?
2. Below is a class. Draw a folder of this class.
 
public class A{
     public static void main(){
         int a= 2 ;
         int b= negate(negate(a)) ;
    }
 
    public static int negate(int x) {
          return(–x) ;
    }
}
3. Find the various syntax and semantic errors in the code given below:
public class A{
      public static void main() {
          String a= "true" 
          String b= false ;
           int d =  diffinlength(a)  
     }
	 
    public static boolean diffinlength(String s1, String s2) {
          return(abs(s1.length – s.length()))
 }   }
4. Starting  with values    a=5   b=23   c=7   d=0   b1=true   b2=false
Find the values of a, b, c, d. Start with the above values for EACH item.
(a) if((a%a)==d) 				(b) d=  b/c ;
          d=  3;				      a=  a–d ;
(c)   a= a*5 ; 				(d) if (b1) b2= true;
        a= a – –5				      if (b2) b1= false;
(e) if (b1 || (a!=3))
         b2= true
5. Give the syntax of the assignment statement and write down how to execute it.
6. Give the syntax of a block and explain how to execute it.
7. Below is a class Employee. 
public class Employee {
	private String name; // employee’s name
	private Date hireDate; // date employee was hired
	/** Constructor: employee named n hired on date d
	public Employee (String n, Date d) { … }
/** = name of the employee */
	public String getName() { …}
/** = hireDate */
	public Date getHireDate() {…}
/** = a representation of the employee, giving their name and date of hire *./
	public String toString() { …}
}
(a) Write the three method bodies (but not the constructor body).
(b) Write a new-expression to create an Employee with name “Roger” who is hired at the time the new-expression is evaluated. Draw the manilla folder that represents the newly created object.
8. Look at class Employee of the previous exercise.
(a) Write a subclass VIP that has a field, bonus, which contains a double value. The subclass needs a constructor that initializes all three fields. Make sure you write the body of the constructor correctly. The subclass should have its own toString function and a getter method for the bonus.
(b) Which components does subclass VIP inherit? Which does it override?
(c) Write another constructor in subclass VIP that has only one parameter, the name of the person. The bonus should be 0 initially, and the date of hire should be 1 february 1979.
9. Consider a class Animal: 
public class Animal {   
    private String kind;    // kind of animal --e.g. "cat"    
    private String name;  // the animal's name    
    // Constructor: an instance with kind k and name s    
    public Animal(String k, String s)
            { kind= k; name= s;}    
    // = description of this Animal   
    public String toString() { 
        return "Name: " + s + ", kind " + k);
    } 
}
Here's an expression that creates an instance:    new Animal("cat", "softy"); 
Write a subclass Lion of Animal that represents lions and also gives their age. The only instance variable of the subclass should be an int variable that contains the age. The constructor should have two parameters —the age and the name. You do NOT have to write the body of the constructor. There should be a getter method for obtaining the age and a getter method for obtaining the name. Override method toString so that a call on it returns a description with all three properties —kind, name, and age. This method should contain a call on the constructor of the superclass.
10. Write the following method. 
/** = the larger of x*y, x*x, and y*2*y */
public static int larger(int x, int y) {
    …
}
11. Given are three int variables x, y, and z. Write a sequence of Java statements to put the larger value in x, the middle value in y, and the smaller value in z.