Outline

Java review:
basics
exceptions
variables
arrays
modulo operator
if statements, booleans, comparisons
loops: while and for

Java review basics

write a simple program, e.g. hello world
how many classes does this program create?
how many objects can you find in this program?
how many methods are implemented by this program?
where does a program begin execution?
how do you declare that?
what is the file name?
how do you print a string?

Java development environment

edit a file using an editor
- which editors have been used by this class?
then compile using?
then execute using?
compilation errors, execution errors are different: how do they differ?
alternative: use an Integrated Development Environment, or IDE
JDK can compile, JRE (included in JDK) can execute
Eclipse, jGrasp are IDEs
Java coding standard helps other people read your programs
ProViz is designed to document the code and help people understand it

Java errors

compilation errors: programmer lack of knowledge, sloppiness, and/or hurry
run-time errors: programmer sloppiness, hurry, and/or lack of understanding
typical run-time error: unexpected input, e.g. a non-numeric string rather than the number which was expected
better programming: check all values to make sure they are as you expect them to be
better programming: deal sanely with values or conditions not being as your main code expects them to be

Java exceptions

try block followed by one or more catch blocks:

try {
  /* code which may throw exception */
}
catch (exceptionClass1 variable1) {
  /* code which handles exception of type exceptionClass1 */
}
catch (exceptionClass2 variable2) {
  /* code which handles exception of type exceptionClass2 */
}
finally {
  /* code executed after try or catch */
}

example (from book, p. 76)

try {
/* something that may cause IOException */
}
catch (IOException ex) {
  ex.printStackTrace();
  System.exit(1);
}

an uncaught exception is caught by the runtime system: this is a run-time error (but not all run-time errors result in exceptions)
an example showing try/catch and command-line arguments
another example program using try/catch and GUI I/O

Java variables

local variables only have scope from their declaration to the end of the block
parameters have scope within the method
smaller declarations override larger declarations, but: this is bad programming practice, since a reader may not know which of multiple equally-named variables the programmer is using, e.g.
count = count + 3;
when there is more than one such variable, this code will modify the innermost count variable
but maybe programmer wants to modify the outer count variable!

Java arrays

arrays are objects
that contain other objects, the array elements
each element is identified by an integer value in (0...array.size-1), the array index or subscript
like any variable, arrays must be declared
unlike integers or booleans, arrays must be initialized, that is, allocated or instantiated, e.g.
```
String [] a = new String [15];
boolean [] bits = new boolean [99];
```
which creates an array of size 15 with indices 0..14
the expression "a [7]" has what type?
see the ChangeDue example

array initialization, operations

an array that is not initialized to an allocated value has the special value null, which cannot be indexed
initializing the array (the container) is different from initializing each of the elements: the array must be initialized first, then the elements
initializing array elements one by one can be as follows
```
   coinNames[4] = "half";
```
This could be done within a loop, e.g.
```
   a[i] = i*7;
```
or all can be initialized and allocated at once, e.g.
```
double [] x = {1.0, 2.71, 3.14, 4.0};
```

the length of an array is one more than the highest usable index

   int i = 0;
   while (i < x.length) {
     x [i] += 1.0;
   }

arraycopy can be used to copy elements from one existing array to another existing array:
```
System.arraycopy(sourceArray, sourcePos,
                 destArray,   destPos,
                 elementCount);
```
all the element positions must be valid, specifically:
- sourcePos through sourcePos + elementCount - 1 on sourceArray, and
- destPos through destPos + elementCount - 1 on destArray

The modulo operator

the operation of dividing two integers gives two results: a quotient and a remainder
For example 11 / 4 = 2 with a remainder of 3

the quotient is given by the division operator:

   int quotient = 11 / 4;  // quotient is assigned the value 2

the remainder is given by the modulo operator:

   int remainder = 11 % 4;  // remainder is assigned the value 3

the remainder operator must be learned since it is used in this class and is commonly used in programming

for example, to get a random binary number (0 or 1), I can do:

   Random myRandomGenerator = new Random();
   int random = myRandomGenerator.nextInt() % 2;

the result is always zero or one

the modulo operator will also be used for queues and hash tables.

Java booleans and boolean expressions

variables of type boolean have either the value true or the value false
expressions of type boolean have either the value true or the value false
for example, x < y is either true or false
arithmetic values or expressions can be used in comparisons:
```
<   <=   ==   !=   >=   > 
```
for objects, == compares the addresses -- are these two the same object -- whereas the equals method may perform a different comparison (and is usually the one to use)
boolean expressions or values can be combined using the logical operators:
```
&&   ||  !
```
boolean expressions and values are used to determine which code gets executed when in conditional statements and loops

Java conditional statements

    boolean b = false;
    if (x > y) {
      a = 3.0;
    } else if (! b) {
      a = 2.2;
    } else {
      x = 99;
    }

the part after the first if is executed if the first condition is true
otherwise the part after the first else is executed, including evaluating the next boolean expression
in-class exercise: determine the output of this program

Java loops

These two sets of statements are equivalent:

    x = 99;
    while(x > 0) {                       for (x = 99; x > 0; x--) { 
       removeBottleOfBeerFromWall();         removeBottleOfBeerFromWall();
       x--;
    }                                    }

a while loop is good when something needs to be done zero or more times:
```
   while(x > 0) {
     x -= y;
     y = y * 2;
   }
```
do .. while can be used to execute statements one or more times:
```
   do {
     x -= y;
     y = y * 2;
   } while(x > 0);
```

a for loop is particularly useful with loop variables:

   for (int i = 0; i < a.length; i++) {
     a [i] *= 2;
   }

What is the output of this code when the argument is 42?

Summary

Java primitives you should already be familiar with
anything you are not familiar with, become familiar with, by using the course resources: the TA in lab, the instructor, the course web page, the textbook (Appendix A), and the reference (The Java Language Specification).
Be sure you know the material in Appendix A of the textbook. Please skim it and make sure you are comfortable with all the subjects in the appendix.
assignment 1 is due on Monday