IT 114: Introduction to Java

IT 114: Introduction to Java
Class 15

Topics

Review

Logical Operators
Truth Tables
Precedence of Logical Operators
The While Loop
The do/while Loop
Infinite Loops

New Material

Augmented Assignment Operators
Updated Order of Precedence
Storing More Than One Value
Getting Values from an Array
The Length of an Array
Creating an Array Object
Initializing Arrays
Changing Array Elements
Index Errors
What Is an Array Variable?
Limitations of Arrays

Homework 6

Homework 6 is due this Sunday at 11:59 PM.

You will find the assignment here.

If you have a problem or a question, make a post on the Class Discussion Area.

Quiz 3

I have posted the answers to Quiz 3 here.

Homework 6

I have posted homework 6 here.

It is due this coming Sunday at 11:59 PM.

Mid-term

The mid-term exam will be given on Monday, March 23rd.

It will consist of questions like those on the quizzes along with questions asking you to write short segments of Java code.

60% of the points on this exam will consist of questions from the Ungraded Class Quizzes.

The other 40% will come from four questions that ask you to write a short segment of code.

The last class before the exam, Friday, March 13th, will be a review session.

You will only be responsible for the material in the Class Notes for that class on the exam.

The Mid-term is a closed book exam.

Due Date for Homework Assignments 2 - 6

The due date for homework assignments 2 - 6 is Friday, March 20th at 11:59 PM.

That is the Friday of the Spring Break.

Any of these assignments submitted after that date will receive a score of 0.

Review

Logical Operators

The logical operators are
- && (and)
- || (or)
- ! (not)
The && (and) operator returns true if both its operands are true
```
	
5 > 4 && 4 > 2 : true
```
If either of its two operands are false, && returns false
```
5 > 4 && 4 < 2 : false
```
It also returns false if both its operands are false
```
5 < 4 && 4 < 2 : false
```
The || (or) operator returns true if either of its operands are true
```
5 > 4 || 4 < 2 : true
```
It only returns false if both of its operands are false
```
5 < 4 || 4 < 2: false
```
The ! (not) operator takes only one operand and reverses its value
So true becomes false
```
! 5 > 4: false
```
And false becomes true
```
! 5 < 4: true
```

Truth Tables

To show how the logical operators work we use truth tables
Truth tables have multiple columns
The first one or two columns are values of boolean variables
The last column shows the boolean result of running the operator on the values
Here is the truth table for && (and)

p q p && q

true true true

true false false

false true false

false false false
The truth table for || (or)

p q p || q

true true true

true false true

false true true

false false false
And the truth table for ! (not)

p ! p

true false

false true

p	q	p && q
true	true	true
true	false	false
false	true	false
false	false	false

p	q	p \|\| q
true	true	true
true	false	true
false	true	true
false	false	false

p	! p
true	false
false	true

Precedence of Logical Operators

When we write an expression like
```
a + b > c and c * d < a
```
there are three different kind of operators
- Arithmetic - +, *
- Relational - >, <
- Logical - and
Operator precedence determines which operators are used before other operators
The logical operators are and, or and not
They have lower precedence than arithmetic operators
They also have lower precedence than the relational operators

The order of precedence is

!	Logical NOT
* / %	Multiplication, division and remainder
+ -	Addition and subtraction
> < >= <=	Relational Operators
== !=	Equality Operators
&&	Logical AND
\|\|	Logical OR

The While Loop

The while loop has the following format


while (BOOLEAN_EXPRESSION){
    STATEMENT;
    STATEMENT;
    ...
}

When the java interpreter comes to a while loop it evaluates the BOOLEAN_EXPRESSION
If it is true it runs the code in the loop body
Then it evaluates the BOOLEAN_EXPRESSION again
It will keep running as long as the expression is true

The `do`/`while` Loop

There is one other conditional loop in Java
The do/while loop

It has the following format


do {
    STATEMENT;
    STATEMENT;
    ...
}
while (BOOLEAN_EXPRESSION);

The difference between the do/while and the while loop is when the boolean expression is evaluated
In a while loop the code block is only executed if the boolean expression is true
That means we test before running the loop code
With ado/while loop the loop body is always executed at least once
But it will not be run again unless the boolean expression is true

Infinite Loops

Conditional loops keep going until their boolean expression becomes false
That means something has to happen in the loop body to make this happen
If this does not happen the loop will go on forever
This is called an infinite loop
When this happens on hold down the Control key while pressing C key

New Material

Augmented Assignment Operators

One of the most common operations in programming is increasing the value of a variable by 1
Or some other amount
This is called incrementing
Sometimes we want to decrease the value of a variable by 1
Or another number
This is called decrementing
Incrementing and decrementing can be done like this
```
x = x + 1;
y = y - 1;
z = z + 2;
```
These operations occur so frequently that Java has special assignment operators for this purpose
```
x += 1;
y -= 1;
z += 2;
```

Using this convenient short-cut we can write a simple program to count by 3

public class CountByThree {
    public static void main (String[] args){
        int num = 1;
        for (int i = 1; i <= 10; i++){
            System.out.println(num);
            num += 3;
        } 
    }
}

$ java CountByThree
1
4
7
10
13
16
19
22
25
28

We can use the the decrement operator to count down by 3

public class CountDownByThree {
    public static void main (String[] args){
        int num = 28;
        while (num >= 1) {
            System.out.println(num);
            num -= 3;
        } 
    }
}

$ java CountDownByThree
28
25
22
19
16
13
10
7
4
1

Operators like this are called augmented assignment operators
There is an augmented assignment operator for each arithmetic operator
So we have *=
Which multiplies the value of the variable on the left by the expression on the right
And assigns this new value to the variable
```
	
x = 5;
x *= 2; # x is now 10
```
We also have /=
Which divides the value of the variable on the left by the expression on the right
And assigns this new value to the variable
```
x = 10;
x /= 2; # x is now 5
```
And %=
Which takes the remainder when the value of variable on the left is divides by the expression on the right
And assigns that to the variable
```
x = 11;
x %= 3; # x is now 3
```

These operators can be read as follows

Expression	Read As
x += 2	add 2 to x
x -= 2	subtract 2 from x
x *= 2	mulitply x by 2
x /= 2	divide x by 2
x %= 2	take the remainder when x is divided by 2

Updated Order of Precedence

All assignment operators have the lowest precedence of any operator we have studied

Description	Operators
Unary operators	! ++ --
Multiplicative operators	* / %
Additive operators	+ -
Relational operators	< > <= >=
Equality operators	== !=
Logical AND	&&
Logical OR	\|\|
Assignment operators	= += -= *=

Storing More Than One Value

Let's say you wanted to take the average of a series of numbers
Where would you store the numbers?
Would you create a separate variable to hold each number?

You could do that for a small set of numbers

public class OneToTen {
    public static void main (String[] args){
        int n1  = 1;
        int n2  = 2;
        int n3  = 3;
        int n4  = 4;
        int n5  = 5;
        int n6  = 6;
        int n7  = 7;
        int n8  = 8;
        int n9  = 9;
        int n10 = 10;

        int total = n1 + n2 + n3 + n4 + n5 + n6 + n7 + n8 + n9 + n10;
        System.out.println("The total of 1 to 10 is " + total);
    }
}

$ java OneToTen
The total of 1 to 10 is 55

But what if you had 100 values?
For situations like Java has a special kind of object called an array
The values in an array are stored one after another
You can get each value in the array by using its position in the sequence of values

Getting Values from an Array

Every value inside an array has its own unique position in the array
We can get that value using the [ ] operator
You place this operator right next to the end of the array variable
And put a number inside it to specify which value you want
The values in an array are called elements
The number put inside the square brackets is called an index
Unfortunately, the number used to get the first element of an array is 0
This is called zero based indexing
For this reason, the index of the last element of an array is one less than the length of the array
As you learned earlier, the agrs parameter contains all the strings on the command line
agrs is an array of strings

So we can use the [] operator to get each command line argument

public class Print3Args {
    public static void main (String[] args){
         System.out.println(args[0]);
         System.out.println(args[1]);
         System.out.println(args[2]);
    }
}

$ java Print3Args foo bar bletch
foo
bar
bletch

The Length of an Array

We can use a for loop to get each value in an array but we have to know the length of the array to do it
One of the pieces of information in an array object is its length
You can get this value using the following format
```
ARRAY_VARIABLE.length
```
To get the length of args we would use
```
args.length
```

Here is an example

public class PrintArgs {
    public static void main (String[] args){
        for (int i = 0; i < args.length; i++){
            System.out.println(args[i]);
        }
    }
}

$ java PrintArgs 1 2 3 4 5
1
2
3
4
5

Now we can use a for loop to compute the average of numbers entered on the command line

public class Average {
    public static void main (String[] args){
    double  = 0;
    for (int i = 0; i < args.length; i++){
        total += Integer.parseInt(args[i]);
    }
    System.out.println("The average is " + total/args.length);
    }
}

$ java Average 1 2 3 4 5 6 7 8 9 10
The average is 5.5

Notice that total is of type double
If it were int we would lose the decimal part of the result
And the output would be 5 instead of 5.5

Creating an Array Object

All the elements of an array must be of the same data type
And you must say how many elements the array will hold when you create it
You create an array variable using the following format
```
DATA_TYPE int VARIABLE_NAME = new DATA_TYPE[LENGTH];
```

Here is a program that creates an integer array with 5 elements

public class IntArray {
    public static void main (String[] args){
        int [] int_array = new int [5];
        for (int i = 0; i < 5; i++){
            int_array[i] = i + 1;
        }
        for (int i = 0; i < 5; i++){
            System.out.println(int_array[i]);
        }
    }
}

$ java IntArray
1
2
3
4
5

To create an array of 5 doubles we would write

public class DoubleArray {
    public static void main (String[] args){
        double [] double_array = new double [5];
        for (int i = 0; i < 5; i++){
            double_array[i] = i + 1.0 ;
        }
        for (int i = 0; i < 5; i++){
            System.out.println(double_array[i]);
        }
    }
}

$ java DoubleArray 
1.0
2.0
3.0
4.0
5.0

Initializing Arrays

If you create a variable of a primitive data type you must give it a value before you use it
When you do this we say you have initialized the variable

If you try to use a variable before you use it you will get an error

public class IntNotInitialized {
    public static void main (String[] args){
        int num;
        System.out.println(num);
    }
}

$ javac IntNotInitialized.java 
IntNotInitialized.java:4: error: variable num might not have been initialized
        System.out.println(num);
                           ^
1 error

Since a primitive data type can only hold one value, this is not difficult
Java will let you initialize a variable on the same line that you define it
```
int num = 0;
```

But arrays do not have to be initialized as you can see from the code below

public class InitIntArray {
    public static void main (String[] args){
        int [] int_array        = new int[3];
        for (int i = 0; i < 3; i++){
            System.out.println("int_array["+ i +"] = " + int_array[i]);
        }
    }
}

$ java InitIntArray
int_array[0] = 0
int_array[1] = 0
int_array[2] = 0

When you create an array, all elements are assigned a default value
A default value is a value that is automatically supplied when you do not provide one
This is feature of Java is called auto-initialization
For an array of each data type there is a different default value

Type Value

int 0

double 0.0

char '\0'

boolean false

Type	Value
int	0
double	0.0
char	'\0'
boolean	false

You can see auto-initialization at work in the code below

public class AutoInit {
    public static void main (String[] args){
        System.out.println("Integer array");
        int [] int_array = new int[3];
        for (int i = 0; i < 3; i++){
            System.out.println(int_array[i]);
        }
        System.out.println("Double array");
        double [] double_array = new double[3];
        for (int i = 0; i < 3; i++){
            System.out.println(double_array[i]);
        }
        System.out.println("Boolean array");
        boolean [] boolean_array = new boolean[3];
        for (int i = 0; i < 3; i++){
            System.out.println(boolean_array[i]);
        }
    }
}

$ java AutoInit 
Integer array
0
0
0
Double array
0.0
0.0
0.0
Boolean array
false
false
false

You can also initialize an array with an array literal
It has the format
```
{VALUE, VALUE, ...}
```

Here is an example

public class ArrayLiteral {
    public static void main (String[] args){
        int [] odds = {1, 3, 5, 7, 9};
        for (int i = 0; i < odds.length; i++){
            System.out.println(odds[i]);
        }
    }
}

$ java ArrayLiteral 
1
3
5
7
9

Changing Array Elements

You can think of each element in an array as a variable
You change the value of a variable like this
```
VARIABLE_NAME = NEW_VALUE
```
Similarly you can change the value of an array element like this
```
VARIABLE_NAME = NEW_VALUE[INDEX]
```
Whenever an array is created its elements are given their default value
We can change each element with a simple assignment statement

Like this

public class ChangeElements {
    public static void main (String[] args){
        int [] numbers = new int[5];
        numbers[0] = 1;
        numbers[1] = 2;
        numbers[2] = 3;
        numbers[3] = 4;
        numbers[4] = 5;
        for (int i = 0; i < 5; i++){
            System.out.println(numbers[i]);
        }
    }
}

$ java ChangeElements 
1
2
3
4
5

Usually though we give elements their values in a loop

public class ChangeElements2 {
    public static void main (String[] args){
        int [] odds = new int[5];
        int n = 1;
        for (int i = 0; i < odds.length; i++){
            odds[i] = n;
            n += 2;
        }
        for (int i = 0; i < odds.length; i++){
            System.out.println(odds[i]);
        }
    }
}

$ java ChangeElements2 
1
3
5
7
9

Notice that I used the array variable length in each for loop
This is a better idea than copying the length of the array from the array declaration
You might mistype the number from the declaration
Or you might change the length of the array and forget to update the for loop

Index Errors

The indexes of an array run from 0 to 1 less than the length of the array
That's why the forloops above also use the < operator in the loop test
If you try to go past the end of an array you will get an error

The following code will compile

public class BoundsTest {
    public static void main (String[] args){
        int [] numbers = new int[5];
        for (int i = 1; i <= 5; i++){
            numbers[i] = 1;
        }
    }
}

But when you try to run it you will get an error

$ java BoundsTest
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
    at BoundsTest.main(BoundsTest.java:5)

What Is an Array Variable?

Many classes ago you learned that a variable can only hold one value
But arrays can hold many values
So how can we have an array variable?
To answer this question we have to talk about what happens when you create an array
Look at this array declaration
```
int [] nums = new int[5]
```
The keyword new tells the Java interpreter to create an array object in RAM
Each element of this object starts out with the default value 0
Like all objects, the array does not have a name
It only has a position in memory
After java create the object it returns it location in memory
We need to store this position in a variable so we can work with the array
So the variable nums does not actually hold the values in the array
It holds the memory address where the array exists in RAM
The picture in memory looks like this

Limitations of Arrays

Arrays have a number of limitations
The two most important are
- Each element must be of the same data type
- The length of a list cannot be changed
The last issue is the most troublesome
You have to know how many values the array will hold when you create it
What if you were reading in values from a file?
You would either have to count the values before creating the array
Or make the array so big that it can hold any reasonable number of values
There are ways around this, but we'll leave that for another class