IT 114: Introduction to Java

IT 114: Introduction to Java
Class 7

Topics

Homework 3

Homework 3 is posted here.

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

Tips and Examples

Read the Assignments Carefully

You need to read the assignments carefully so you understand all that is required
You may need to do this more than once
Take the time to read the assignment documents in detail
If you don't, you will make mistakes and lose points
Technical work is detailed work
You must learn to read technical documents slowly and carefully
If you don't, you will miss important points
If you do not understand something, post it on Piazza
NEVER GUESS what is needed for an assignment

Do Not Fall Behind in This Course

Technical courses require that you master a great deal of detail
You need to set aside time to work on this course several days during the week
Don't fall into the trap of studying only on weekends
Some difficult material only sinks in after a day or two of thinking about it
The key to success in a technical course is consistent work throughout the semester
It is critical that you keep up with your studying for this course
If you fall behind it can be VERY hard to catch up

Review

Operators

The characters + and - are operators
Operators are special characters that perform an action
Usually the operator creates a new value
Operators work on one or more values
These values are call operands
There are many different kinds of operators in Java
But we will start out with the operators used in arithmetic

Arithmetic Operators

Java has five arithmetic operators

Operator	Meaning	Example	Result
+	addition	2 + 2	4
–	subtraction	53 – 18	35
*	multiplication	3 * 8	24
/	division	4 / 2	2.4
%	remainder or modulo	19 % 5	4

The Mod Operator

Division with integers returns two values
- The quotient
- The remainder
Let's look at an example
```
17 / 5
```
In integer division, the quotient is always an integer
In the expression above, the quotient is 3
But there is also a remainder which is also an integer
In this case, the remainder is 2
In Java % is the remainder operator
This operator is something called the modulus operator

Two Groups of Data Types

There are two groups of data types
- Primitive data types
- Classes
Primitive data types can only hold one value
Classes define objects which can hold many values

Strings

The char data type can only hold one character
But String can hold as many as you want
Strings are a sequence of characters, one right after the other
Strings can include spaces and tabs
Whenever a program contains a string written out inside the code string literal
In Java, a string literal must be enclosed with double quotation marks
You must use double quotes, not single quotes
A string literal must be on a single line
It cannot continue onto the next line
We will only be using strings in this course

Concatenation

You can make a new string by joining two existing strings
This is called concatenation
We join two strings together using the + operator

Concatenating Strings and Numbers

You can use concatenation to join a string and a number
Java knows the data type of each variable and literal
If the value in front of + is a number
It knows that + means addition
If the value is a string, it knows + means concatenation
Java can't concatenate a string with a number
So it turns the number into a string

New Material

Expressions

When we write programs we are always dealing with values
These values can be of several data types
- int
- float
- boolean
- String
But there are many different ways that we can get a value inside our code
The value can be a literal
The value can also be held inside a variable
Or we can calculate the value using operators
Each of these is an expression
An expression is anything in Java that can be turned into a value
At the moment you only know three types of expressions in Java
- Literals
- Variables
- Calculations using operators

Here is a bit of Java code with examples of each

	
int number = 5;
System.out.println("Literal     6 -> " + 6);
System.out.println("Variable    number -> " + number);
System.out.println("Calculation number * 3 -> " + number * 3 );

when run, the output is

Literal     6 -> 6
Variable:   number -> 5
Calculation number * 3 -> 15

There is a fourth expression type that we will meet in a future class

Evaluating an Expression

Expressions are important to a compiler
javac processes the code statement by statement
Each expression in a statement must be turned into a value
This has to be done before the compiler can produce the bytecodes for the statement
Turning an expression into a value is called evaluation

Look at the following two statements

System.out.println(4);
System.out.println(x);
System.out.println(4 + x);

In each case, what is inside the parentheses is an expression
The value obtained from evaluating an expression is called the result
Consider the following calculation
```
(4 + x) / (4 - y)
```
The operations inside the two parentheses must be evaluated first
Then we can divide the two values
So we have three separate evaluation of operators
- Evaluation of (4 + x)
- Evaluation of (4 - y)
- Division of the results
Using this technique you can build up very complicated expressions
This poses no problems to the compiler
It just finds the lowest level expressions and evaluates them
Then it moves up to the next level
And performs the operations specified there

Precedence

Compilers must have rules in order to do their job
The rules must make it clear in any situation what to do
There must be no ambiguity about any statements written in Java
Consider the following expression
```
3 + 2 * 4
```
This expression has two operators
Which operation should be done first?
If we do addition first we get
```
3 + 2 = 5
5 * 4 = 20
```
But if we do multiplication first we get
```
2 * 4 = 8
3 + 8 = 11
```
Java uses rules of precedence in situations like this
The rules of precedence tell the compiler which operator to apply first
Operators with higher precedence are used before operators of lower precedence
For arithmetic operators there are two orders of precedence
Operators that deal with multiplication and division
- *
- /
- %
have the higher order of precedence
Operators that deal with addition and subtraction
- +
- -
have a lower order of precedence
Some people remember this using the phrase "my dear aunt sally"
- my = multiplication
- dear = division
- aunt = addition
- sally = subtraction
Consider the expression
```
3 + 2 * 4
```
The Java compiler would evaluate this as follows
```
3 + 2 * 4 = 3 + 8 = 11
```
Because multiplication has a higher order of precedence than addition
But what happens if two operators have the same order of precedence?
Then the compiler evaluates them left to right
With operators of the same precedence it does not matter which is done first
```
3 * 6 / 2 = 18 / 2 = 9
```
What if you wanted the operators evaluated in a different order?

Then you have to use parentheses

3 + 2 * 4   = 3 + 8 = 11
(3 + 2) * 4 = 5 * 8 = 40

Parentheses always overrule the order of precedence
If you are ever in doubt about how the compiler will evaluate an expression ...
use parentheses

Escape Sequences

When we think about characters we usually think about letters, digits and punctuation
But there are a few unusual characters that require special treatment
There is a character called newline that makes the output go down to the next line
This is the character you get when you hit Enter on a PC
Or Return on a Mac
But this won't work inside a string literal

If you try it you will get many errors

System.out.println("Line 1
Line 2");

results in

	

error: ';' expected
System.out.println("Line 1
                   ^
error: unclosed string literal
System.out.println("Line 1
                          ^
error: unclosed string literal
Line 2");
      ^
error: not a statement
Line 2");
       ^
4 errors

Another character that caused problems is Tab
When you hit tab in an editor, a couple of spaces appears in the text
But computer languages all recognize a Tab character
If you want to use these or other troublesome characters you have to use an escape sequence
An escape sequence is a set of two characters
The first of which is a backslash, \
Here is a list

Sequence Represents

\t tab character

\n new line character

\" double quote

\\ backslash

Sequence	Represents
\t	tab character
\n	new line character
\"	double quote
\\	backslash

You can use an escape sequence to print more than one line of output with a single println

$ cat ThreeLines.java 
public class ThreeLines {
    public static void main(String[ ]  args)  {
        System.out.println("Line 1 \nLine 2 \nLine 3") ;
    } 
}

$ java ThreeLines
Line 1 
Line 2 
Line 3

Control Structures

When the interpreter run a script it goes through the code statement by statement
The order in which it executes the statements is call the flow of control
Or the path of execution
In all the scripts you have seen so far the path is very simple
Start at the top of the program executing each statement until you get to the end
If this were the only way Python could run a program it wouldn't be very useful
To provide more flexibility in programmers Python has control structures
Control structures allow the interpreter to take different paths through the code
There are two types of control structures in Java
- Loops
- Branches or Conditionals

Loops

There are two kinds of loops in Java
- Loops controlled by counting
- Loops controlled by some condition
Loops controlled by counting are sometimes called definite loops
Loops controlled by a condition are sometimes called indefinite loops
All loops are composed of two parts
- A loop header
- A loop body
The loop header is a single line at the top of the loop
It controls how many times the loop runs
The loop body are the statements that are executed with each pass through the loop
Each pass through the loop body is an iteration

Code Blocks

The loop body is an example of a code block
Code blocks are a group of statements that are only executed under certain conditions
In Java code blocks are contained between left curly brace, {
And a right curly brace, }
Every { must be followed by a matching }
Or you will get an error
You should indent the statements inside a code block
The compiler won't care
But it will make your code more readable
And readable code is easier to fix when you get an error

The ++ and -- Operators

There are two additional arithmetic operators that I did not mention earlier
I omitted them because they are not used the same way as the others
They are mostly used in loops
They are unary operators because they only take one operand
++ adds 1 the value of the variable it is placed next too
-- subtracts 1 from its variable

They are unusual because they can be place before or after a variable

public class PlusPlusMinusMinus {
    public static void main (String[] args){
        int number = 5;
        System.out.println("number: " + number);
        number++;
        System.out.println("number: " + number);
        ++number;
        System.out.println("number: " + number);
        number--;
        System.out.println("number: " + number);
        --number;
        System.out.println("number: " + number);
    }
}

$ java PlusPlusMinusMinus
number: 5
number: 6
number: 7
number: 6
number: 5

There is a slight difference in how they work depending on where they are placed
But we won't need to worry about that
Adding 1 to the value of a variable is called incrementing
Subtracting 1 from the value of a variable is called decrementing

Order of Precedence for ++ and --

Here is how the new operators fit into the precedence hierarchy

Description Operators

unary operators –– –

multiplicative operators / %

additive operators –

assignment operators += *= %=