IT 114: Introduction to Java

IT 114: Introduction to Java
Class 20

Topics

Review

Objects
Classes
Statements
Printing a Line in Java
Data Types
The Java Data Types
Variables
Declaring Variables
Assignment Statements
Literals
= Does Not Mean Equals
Java Is Case Sensitive
Printing Variables
Operators
Arithmetic Operators
The Mod Operator
Two Groups of Data Types
Strings
Concatenation
Concatenating Strings and Numbers
Expressions
Evaluating an Expression
Precedence
Escape Sequences
Control Structures
Loops
Code Blocks
The ++ and -- Operators
Order of Precedence for ++ and --
The for loop
Initializing the Loop Variable
The Loop Test
The Loop Update Statement
The for Loop in Action
for Loop Patterns
Keywords
Mixing Data Types
Integer Division
Defining Methods
Method Headers
Running a Method
Arguments and Parameters
Returning Values
Return Type in Method Header
Method Calls Can Be Expressions
The main Method
Getting Input from the Command Line
Converting Strings to Integers
Conditionals or Branches
The boolean Data Type
Relational Operators
if Statements
if/else Statements
Nested if Statements
if/ else if Statements
Relational Operator Precedence
Casting
Logical Operators
Truth Tables
Precedence of Logical Operators
The While Loop
The do/while Loop
Infinite Loops
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
What Is an Array Variable?
Objects
Strings
We Have Been Defining Unusual Classes
Two Kinds of Methods
Dot Notation
String Methods
charAt(index)
length()
split(text)
trim()
The Empty String
Strings Cannot Be Changed
Packages
Using Java Packages
Importing Packages
Using a Scanner Objects
Scanner Methods

Homework 7

Homework 7 is not due this Sunday.

Instead it is due the Sunday after the Mid-term Exam.

This will give you time to study for the exam.

You will find the assignment here.

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

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.

Today's class will be a review session.

You will only be responsible for the material in the Class Notes for today's 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.

It is also the due date for Class Exercises 2 - 17

That is the Friday of the Spring Break.

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

Today's Class

There will be no Class Quiz or Class Exercise for today's class.

Review

Objects

Java is an object oriented language
But what are objects
An object is a section of a computer's RAM
An object can hold many values
Along with code that can work with these values
There is no limit to the number of values an object can contain
Objects only exist when the program that created them is running

Classes

Objects have to be defines before you can create them
The definition are a type of software called a class
Classes are software written in Java
Objects are the contents of RAM created from a class when a Java program is run
There is only one class for each type of object
A single class can create many objects

Statements

A Java program consists of a number of statements
A statement is a line or lines of code that represent a complete action
There are two kinds of statement
- Simple statements
- Compound statements
A simple statement can be written on a single line and contains no other statements
A compound statement contains other statements within it
All statements must end with a semicolon, ;
If you don't you will get an error when you compile it

Printing a Line in Java

The first Java statement you need to learn prints a line of text
It has the following form
```
System.out.println(STRING);
```
This may seem like a lot of characters to perform a simple action
The statement looks like this due to Java's object oriented design
The javac compiler objects because it does not know println
If the parentheses are empty it simply prints a blank line

Data Types

The basic job of any program is to create and manipulate data
And data comes in many forms
Each of these forms must be represented in RAM in the most efficient way possible
To do this, each computer language has different data types
Each of these data types specifies how a value is to be represented in RAM
Some languages, like Python and Perl, are very easy going with respect to data types
But Java is not one of them
Java is a type-safe language
Another term for this type of language is strongly typed
In a type-safe language, you have to assign a data type to each value
The data type of a value determines what you can do with it

The Java Data Types

There are 8 data types in Java
But we will only use 4 of them

int integer

double decimal

bool boolean

char character

Variables

A variable is a place in RAM that holds one value
And has a name
Variables are much simpler than objects
Objects can store many values, not just one
And they can contain code
Objects do not have names
They have locations in RAM

Declaring Variables

A variable in Java can only values of one data type
In Java you must create the variable before you use it
You do this with a variable declaration
A variable declaration is a statement
It uses the following format
```
DATA_TYPE VARIABLE_NAME ;
```

Here are some examples

int number;
double interest;
char ch;
bool finished;

Assignment Statements

You give a variable a value with an assignment statement
It has the following format
```
VARIABLE_NAME = VALUE
```

Here are some examples

number = 5;
interest = .065;
ch = 'x';
finished = false;

When we give a variable its first value we are said to initialize the variable
Declaring a variable does not give it a value
If you try to use a variable before you initialize it you will get an error
Java lets you combine declaring and initializing a variable in single statement with the following format
```
DATA_TYPE VARIABLE_NAME = VALUE ;
```

Here are some examples

int number = 5;
double interest = .065;
char ch = 'x';
bool finished = false;;

Literals

In the statements above we wrote the values of the variables directly inside the the source code file
These values are examples of literals
Programmers sometimes refer to such values as "hard coded"

= Does Not Mean Equals

= is an example of an operator
Operators are special characters that perform an action using one or more values
= is the assignment operator
It takes the value on the right hand sign and gives it to the variable on its left
In arithmetic means equals
But that is not what is really going on with = in Java
Because the value of a variable can change
When you read a line of code like this
```
number = 5
```
You should not say "number equals 5"
You should say "number gets 5"

Java Is Case Sensitive

Both Unix and Java are case sensitive
This means that UPPERCASE (CAPITALS) and lowercase (like this) letters are completely different
This means that the following variable names are are different variables
```
first_name
First_Name
First_name
FIRST_NAME
```
To keep things simple and avoid errors, use lowercase only for variable names

Printing Variables

Once you have defined a variable and given it a value you can use println to print it
```
int number = 1;
System.out.println(number);
```
Notice that there were no quotes, "" around number

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

Expressions

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
There is a fourth expression type that we will meet in a future class

Evaluating an Expression

The Java compiler 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
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 evaluations 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

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
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

There are a few unusual characters that require special treatment
Because they cannot be written inside a string in the normal way
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 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

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
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

++ adds 1 the value of the variable it is placed next too
-- subtracts 1 from its variable
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 ++ and -- fit into the precedence hierarchy

Description Operators

unary operators –– –

multiplicative operators / %

additive operators –

assignment operators += *= %=

Description	Operators
unary operators	–– –
multiplicative operators	/ %
additive operators	–
assignment operators	+= *= %=

The `for` loop

The most frequently used loop is the for loop
The for loop is a definite loop
Because we specify how many times it loops in the loop header
The loop header controls the loop
The header of the for loop has the following format
```
for (INITIALIZATION; LOOP_TEST; UPDATE)
```
The parentheses contains three separate statements
Which must be separated by semicolons
This is followed by the loop_body
Which contains the statements that are run with each pass through the loop
The loop body is inclosed in curly braces, { }
And should be indented

Initializing the Loop Variable

The first statement in the loop header initializes a variable that controls the loop
It is called the loop variable
This variable must be an integer
The initialization gives the loop variable it's first value
Which is often 0 or 1
This statement is only executed once
And that happens before entering the loop

The Loop Test

The second statement in the loop header determines how many times the loop runs
It is a boolean expression which test the loop variable
As long as this expression is true the loop will run
A for loop stops when the test becomes false
Usually the expression is true as long as the loop variable is less than some value

The Loop Update Statement

The update statement changes the value of the control variable
This happens after the statements in the loop body have been run
But before the loop test is run
The most common update is to add 1 to the loop variable
Usually this is done using the ++ operator

The `for` Loop in Action

Here is the flow chart for a for loop

First we give the control variable its starting value
This happens only once
Then the loop test is run
If the loop returns true all the statement in the loop body are run
After the last statement in the loop body, the update statement is run
Then we run the loop test again
If the result is true, we run the statements in the loop body again
If not, we jump out of the loop
And run the first statement after the loop

`for` Loop Patterns

The most common for loop pattern is


for (int  VARIABLE_NAME = 1;  VARIABLE_NAME  <= LIMIT;  VARIABLE_NAME++)  {
    STATEMENT;
    ...
}

Sometimes it is more convenient to start counting from 0 instead of one

Here is the pattern


for (int  VARIABLE_NAME  = 0;  VARIABLE_NAME  <  LIMIT;  VARIABLE_NAME++)  {
    STATEMENT;
    ...
}

Keywords

Certain words keep appearing over and over again in Java programs

For example, consider the following code

	
public class HiHo { 
    public static void main(String[ ]  args)  {
        for (int i = 1;  i <= 5;  i++)
            System.out.println("Hi!") ;
        System.out.println("Ho!") ;
    }
}

The words in red have special meaning in the Java language
They are called keywords
Keywords cannot be used as the names of variables

Mixing Data Types

What happens when you mix values of two different data types in a calculation?
For example, how would the compiler handle the following
```
4 * 3.3
```
Java has a simple rule for handling situations like this
Convert the result to a data type that gives the most information
In the example above an int multiplies a double
If the result were converted into an int the value would be 13
```
4 * 3.3 -> 13
```
But if the result is converted to double we get
```
4 * 3.3 -> 13.2
```
The first example is less precise than the second
Java always uses the data type that will not lose precision

Integer Division

Integer division works differently than decimal division
```
5 / 2 -> 2
5.0 / 2.0 -> 2.5
```

If you want the result of integer division to be a decimal, multiply the result by 1.0

public class IntDivision {
    public static void main(String[ ]  args)  {
        int n1 = 5;
        int n2 = 2;
        System.out.println("5/2 -> " + n1/n2);
        System.out.println("1.0 * 5/2 -> " + 1.0 * n1/n2);
    } 
}

$ java IntDivision 
5/2 -> 2
1.0 * 5/2 -> 2.5

Defining Methods

You define a method with a special kind of Java statement called a method declaration
A method declaration has two parts
- A method header
- A method body
The method body is a code block containing the Java statements that are executed each time the method is run
The method header specifies
- What Java programs can use the method
- What kind of value it creates
- The method name
- What values it needs when it is run

Method Headers

The method header has the following format


MODIFIER [static] RETURN_DATA_TYPE METHOD_NAME(PARAMETER_LIST)

The MODIFIER determines which other Java programs can use the method
In this class we will only use public as the modifier
static is enclosed in square brackets, [ ], in the format above
That means the keyword static is optional
For now will use static in the header for the methods we define
The method name comes next
Followed the the PARAMETER_LIST inside parentheses

The parameter list has the following format


DATA_TYPE PARAMETER_NAME[, DATA_TYPE PARAMETER_NAME ...]

The [, DATA_TYPE PARAMETER_NAME ...] mean you can have multiple parameters
Parameters are special variables inside the method code

Running a Method

To run a method we use a special kind of statement called a method call
It has the following format
```
METHOD_NAME(ARGUMENT_LIST);
```
The ARGUMENT_LIST are values separated by commas
How many values appear appear between the ( ) depends upon the method
There can be zero, one or many values

The program GoTeam2.java contains 4 method calls

cheer("Sox");
...
cheer("Pats");
...
cheer("Celtics");
...
cheer("Bruins");

Each method call uses a different value inside the parentheses
When you run java on your program it goes through the code statement by statement
When java comes to a method call it jumps to the statements inside the method body
When it finishes with these statements, it jumps back to the method call

Arguments and Parameters

Methods can have variables just like any other piece of Java code
The variables defined inside a method are called local variables
Local variables can only be used inside the method where they are defined
No other part of the program can see them
Or use them
A parameter is a special kind of local variable
Parameters get their values from the arguments in a method call
The cheer method has a single parameter
```
public static void cheer (String team)
```
When the program makes the first method call
```
cheer("Sox");
```
team get the value "Sox"
When the program makes the second method call
```
	
cheer("Pats");
```
team get the value "Pats"
And so on

Returning Values

When a method creates a value and sends it back to the the method call, we say it is returning a value
This is done with a return statement which has the following format
```
return EXPRESSION
```
When the java interpreter comes to a return statement it does the following
- Causes the running of the method to stop
- Sends the value of EXPRESSION back to the method call
So a method stops running when it gets to a return statement

Return Type in Method Header

The method header has to specify the kind of value each method returns
It does this using the return type that appears in the method header right before the method name
Even if the method does not return a value, it still needs a return type
The return type for a method that returns nothing is void

Method Calls Can Be Expressions

Methods that have a return statement provide a value to the method call
We call anything that can be turned into a value an expression
So a call to a method that returns a value is also an expression
So an expression can be
- A literal
- A variable
- A calculation with operators
- A call to a method that returns a value

The main Method

The real work in Java programs is done by methods
A well written program breaks a big problem down into a number of methods
The main method then calls the methods to do the work required
If the method names are well chosen, simply reading the method calls in the main method gives a good idea of what the program does
The main method in Java is special
All other methods have to be called to run
Not the main method
It is automatically called when you run the Java file
You cannot run a Java file if it does not have a main method
The method drives the work of the program

Getting Input from the Command Line

We can do the same with Java programs
Look at the header for the main method
```
public static void main(String[] args)
```
main has the single parameter args
The data type String[] means it is an array of strings
Arrays are lists of things
args contains all the command line arguments used when running the program
Since there can be many command line arguments, we have to specify which argument we want
To get the first command line argument use
```
args[0]
```

Converting Strings to Integers

The args parameter in the main lets a Java program use command line arguments
But command line arguments are strings
If () wanted to convert the String variable input into an integer I would write
```
Integer.parseInt(input);
```

Conditionals or Branches

Conditional control structures are like switches on a railroad track
Which path the train takes depends on how the switch is set
When the java interpreter comes across a conditional statement it has to make a decision
It has to decide what statements to execute next
Usually it makes this decision by evaluating an expression whose only possible values are true and false
There are four conditionals in Java
But for the moment we will only consider three
- The if statement
- The if/else statement
- The if/else if statement

The `boolean` Data Type

A variable of type boolean can only have the values true or false
The name comes from the British mathematician George Boole who invented this field of mathematics
A boolean expression is an expression whose only possible values are true and false
There are two boolean literals
- true
- false

Relational Operators

All if statements evaluate boolean expressions
Usually, these expressions involve relational operators
Relational operators compare two boolean values
And return either true or false

The format for a relational expression is


BOOLEAN_VALUE  RELATIONAL_OPERATOR  BOOLEAN_VALUE

Java provides the following relational operators

Operator	Meaning	Example	Value
==	equal to	2 + 2 == 4	true
!=	not equal to	3.2 != 4.1	true
<	less than	4 < 3	false
>	greater than	4 > 3	true
<=	less than or equal to	2 <= 0	false
>=	greater than or equal to	2.4 >= 1.6	true

Notice that the equality operator is ==
Not =
This is a mistake that is easy to make
And you will probably make it often as you write Java programs

`if` Statements

The simplest conditional control structure is the if statement
An if statement contains other statements inside it
These statements are only run if certain conditions are met

It has the following format


if (CONDITION){
    STATEMENT
    STATEMENT
    ...
}

The CONDITION is a boolean expression
The statements inside the code block are run if the CONDITION is true
If not, the statements are skipped

`if`/`else` Statements

An if/else statement has the following format


if (CONDITION){
    STATEMENT;
    STATEMENT;
    ...
} else {
    STATEMENT;
    STATEMENT;
    ...
}

If CONDITION is true the code block following the header is executed
Otherwise the code block following else is run

Nested `if` Statements

if statements are compound statements
That means they can have statements inside them
An if statement is a statement
So you can have an if statement inside an if statement
Just like you can have a for statement inside a for statement
This called a nested if statement

`if`/ `else if` Statements

An if/else if statement gives us many different paths through the code

It has the form

if (BOOLEAN_EXPRESSION_1) {
    STATEMENT;
    ...
} else if (BOOLEAN_EXPRESSION_2) {
    STATEMENT;
    ...
...
[ else {
    STATEMENT;
    ...
{

The code block following the first boolean expression that evaluates to true is run
Followed by the code after the if/else if statement
If there is an else clause, its code block will be run if no boolean expression evaluates to true
If there is no else clause, no code blocks are executed

Relational Operator Precedence

Here is a more complete listing of operator precedence showing where the relational operators fit n=in

Description	Operators
Unary operators	`++ --`
Multiplicative operators	`* / %`
Additive operators	`+ -`
Relational operators	`< > <= >=`
Equality operators	`== !=`

Casting

Java is a strongly typed language
Scripting languages like Python are flexible about data types
But Java is not
Python recognizes different data types
But it has methods that will turn one data type into another
Java uses a different approach
You can force a variable of one data type to behave like another by using a cast
It uses the following format
```
(DATA_TYPE) EXPRESSION
```
So if the variable num was a double but I needed an int I would write
```
(int) num
```

Logical Operators

The logical operators are
- && (and)
- || (or)
- ! (not)
The && (and) operator returns true if both its operands are true
It also returns false if both its operands are false
The || (or) operator returns true if either of its operands are true
It only returns false if both of its operands are false
The ! (not) operator takes only one operand and reverses its value
So true becomes false
And false becomes 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

Augmented Assignment Operators

One of the most common operations in programming is increasing the value of a variable by 1
This is called incrementing
Sometimes we want to decrease the value of a variable by 1
This is called decrementing
Java provides special assignment operators that combine shortcuts to change the value of a variable with a simple arithmetic operation
These operators are called augmented assignment operators

They are

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

A variable can only hold one value
But objects can hold as many values as you wish
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

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
```

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];
```

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
Array elements are automatically initialized when they are created with default values
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
You can also initialize an array with an array literal
It has the format
```
{VALUE, VALUE, ...}
```

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

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]
```
The INDEX is an integer running from 0 to one less than the length of the array

What Is an Array Variable?

Like all objects, arrays do not have a name
They have a position in memory
The statement that creates an array returns a memory address
We need to store this position in a variable so we can work with the array
The variable does not hold the values in the array
It holds the memory address where the array exists in RAM
The picture in memory looks like this

Objects

Objects are sections of RAM that can contain more than one value
They can also contain methods that act upon there values
These values are called attributes or fields or properties
Objects do not have a name, just a position in RAM
When you create an object its position must be stored in a variable
Otherwise you will not be able to use the object
The values and methods an object contains are defined by a class
Classes serve as the template or blueprints used to create an object
Java is an object-oriented language
A program in Java consists of one or more files
Each of these files contain at least one class

Strings

Strings are objects because they contain many values
The format for declaring and initializing an array is
```
String VARIABLE_NAME = STRING_LITERAL;
```
A is a sequence of letters written out inside a Java program
String literals must be enclosed in double quotes, "
```
String greeting = "Hello";
```
Two strings can be joined to form a third string using concatenation
This is done using the concatenation operator, +
```
System.out.println(greeting + "John");
```

We Have Been Defining Unusual Classes

All the Java programs you have seen so far are unusual
Because they cannot be used to create an object of their class
We will talk more about this in a future class
All other Java classes can be used to create an object of their class

Two Kinds of Methods

A method is a collection of statements that perform a specific task
All methods are defined inside a class
In Java you can define two kinds of methods
- Methods that work with the values inside an object
- Methods that do not work with values inside an object
Methods of the first type can only be used on an object that you create from the class
These are the most common type of Java methods
The second type are called static methods
When we created programs to turn scores into grades we called a method to convert string values into integers
```
number = Integer.parseInt(input);
```
parseInt is a method of the Integer class
We did not have to create an Integer object to use this method
Similarly when we created the rand_int method for our dice games, we did not have to create an object

The method declaration looked like this

public static int rand_int(int max, int min){
    double value = Math.random() * (max - min)  + min;
    return (int) value;
}

The keyword static means an object does not have to be created to use this method
In a certain sense, static methods live inside a class
While all other methods live inside their objects

Dot Notation

When we are calling a method defined inside the current class we just use the name of the method
When we call a method outside the current class we have to use dot notation

Dot notation has the following format


CLASS_NAME_OR_OBJECT_NAME.METHOD_NAME(PARAMETER_LIST

When we are calling a static method we use the name of the class before the dot
```
int score = Integer.parseInt(input);
```

For all other method calls we use the name of the variable pointing to the object

String name = "John Smith"
System.out.println(name + " is " name.length() + " long");

String Methods

Here is a list of some of the more useful String methods

Method	Description	Return Type
charAt(index)	Returns the character at a specific position	`char`
contains(text)	Returns true if the string contains the text	`boolean`
length()	Returns the number of characters in the string	`int`
split(text)	Returns an array of strings. The text is used to mark off each string from the next	`String []`

charAt(index)

A string is like an array of characters
But you can't use the [] operator with strings
You use the charAt method instead
As with arrays you use zero-based indexing
So the index of the first character is 0

length()

length returns the length of the string

We can use length along with charAt to loop through the characters in a string

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

$ java StringLoop 
Tommy
name.charAt(0) T
name.charAt(1) o
name.charAt(2) m
name.charAt(3) m
name.charAt(4) y

split(text)

split splits a string into an array of strings
In order to spilt the string into small sub-strings we need to know characters to use as the border between adjacent sub_strings
The string that serves as the boundary is called a delimiter
For example say we had the following string
```
"John, Smith, 0124353"
```
Here the delimiter is ", "

The code below shows split in action

public class SplitString {
    public static void main (String[] args){
        String string    = args[0];
        String delimiter = args[1];
        String [] fields = string.split(delimiter);
        for (int i = 0; i  fields.length; i++){
            System.out.println(fields[i]);
        }
    }
}

$ java SplitString "John, Smith, 0124353" ", "
John
Smith
0124353

$ java SplitString "2020-01-10" "-"
2020
01
10

trim()

trim returns a new string with whitespace characters from the beginning and end of the string removed
The whitespace characters are

Space ' '

Tab '\t'

Newline '\n'

The Empty String

The empty string is a string with nothing in it
The empty string acts like zero for strings
If you add a number to zero the result is the number you added
This is also true for the empty string

Strings Cannot Be Changed

String objects are immutable
That means they cannot be changed
This was a design decision made by the the creators of the Java language
Every time a string is created while running a Java program it is put in a special place called a string pool
So when we write
```
s1 = "dog"
```
This is the picture in memory

But if the program creates another string with the same characters a new String object will not be created
Instead a new variable will point to an existing string with the same characters
```
s2 = "dog"
```

This is done to save memory space
What happens when you assign a new string to the variable s1?
In that case the a new string object is created
But the old one remains in memory
```
s1 = "cat"
```

What happens when you use one string to create another by concatenation?
Again a new string is created
```
s1 = s1 + "food"
```

Packages

There are literally thousands of classes in Java
There are so many that there was a need to arrange them in some order
This is done by collecting classes into packages
A package is a collection of related Java classes

Using Java Packages

There are hundreds of Java packages
To use a class in a program its package must be brought into the RAM of a running program
Bringing a package into RAM is called importing
There are so many packages that it is impossible to import them all
Instead the Java interpreter automatically imports a package with many classes useful for a broad range of task
The name of this package is java.lang
It includes a number of basic Java classes
- System
- String
- Math

Importing Packages

To use a class that is not included in java.lang you need to make an import declaration
It has the following form
```
import PACKAGE_NAME.CLASSNAME;
```
If you want to import all of the classes in a package you would write
```
import PACKAGE_NAME.*;
```
The java.util package has many useful packages
To import a class from this package you would use the following format
```
import java.util.CLASS_NAME
```
All important declarations must appear at the top of the Java source code file
Before any class declarations appear

Using a Scanner Objects

A Scanner object allows a Java program to ask the user input from the command line

You first create a Scanner object like this


Scanner SCANNER_VARIABLE = new Scanner(System.in);

Of course you need to tell the user what kind of information the program needs
You do this by printing a prompt
A prompt is a short message that tells the user that input is needed
It is best to use System.out.print to print the prompt
That way the user will enter data on the same line as the prompt
You then call one of a number of methods on the Scanner object to get what the user enters

Scanner Methods

The Scannerobject provides different methods to do this to return data of different types

Method	Description
next()	Reads and returns the next token as a String
nextDouble()	reads and returns a `double` value
nextInt()	reads and returns an `int` value
nextLine()	reads and returns the next line of input as a String

Whenever you call one of these Scannermethods, it
- Waits for the user to type in some data and hit Enter or Return
- Takes in the data entered at the keyboard as a string
- Converts that data into a value of the right data type
- Returns that data to the statement that called it

Space	' '
Tab	'\t'
Newline	'\n'

Topics

Review

Homework 7

Mid-term

Due Date for Homework Assignments 2 - 6

Today's Class

Review

Objects

Classes

Statements

Printing a Line in Java

Data Types

The Java Data Types

Variables

Declaring Variables

Assignment Statements

Literals

= Does Not Mean Equals

Java Is Case Sensitive

Printing Variables

Operators

Arithmetic Operators

The Mod Operator

Two Groups of Data Types

Strings

Concatenation

Concatenating Strings and Numbers

Expressions

Evaluating an Expression

Precedence

Escape Sequences

Control Structures

Loops

Code Blocks

The ++ and -- Operators

Order of Precedence for ++ and --

The for loop

Initializing the Loop Variable

The Loop Test

The Loop Update Statement

The for Loop in Action

for Loop Patterns

Keywords

Mixing Data Types

Integer Division

Defining Methods

Method Headers

Running a Method

Arguments and Parameters

Returning Values

Return Type in Method Header

Method Calls Can Be Expressions

The main Method

Getting Input from the Command Line

Converting Strings to Integers

Conditionals or Branches

The boolean Data Type

Relational Operators

if Statements

if/else Statements

Nested if Statements

if/ else if Statements

Relational Operator Precedence

Casting

Logical Operators

Truth Tables

Precedence of Logical Operators

The While Loop

The do/while Loop

Infinite Loops

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

What Is an Array Variable?

Objects

The `for` loop

The `for` Loop in Action

`for` Loop Patterns

The `boolean` Data Type

`if` Statements

`if`/`else` Statements

Nested `if` Statements

`if`/ `else if` Statements

The `do`/`while` Loop