1. The System.exit() Method
The System.exit method requires an integer argument.
System.exit(0);
This argument is an exit code that is passed back to the operating system.
This code is usually ignored, however, it can be used outside the program:
to indicate whether the program ended successfully or as the result of a failure.
The value 0 traditionally indicates that the program ended successfully.
We will learn about handling Exceptions so this will become less important except perhaps in debugging or when you want your program to end as part of the exception handling.
From Gaddis – Chapter 2 – slide 9

2. The Parse Methods
Each of the numeric wrapper classes, Chapter 8, has a static method that converts a string to a number.
The Integer class has a method that converts a string to an int,
The Double class has a method that converts a string to a double, and
etc.
These methods are known as parse methods because their names begin with the word “parse.”
From Gaddis – Chapter 2 – slide 11

3. The Parse Methods byte bVar = Byte.parseByte("1"); // Store 1 in bVar.
int iVar = Integer.parseInt("2599");
// Store 2599 in iVar.
short sVar = Short.parseShort("10");
// Store 10 in sVar.
long lVar = Long.parseLong("15908");
// Store in lVar.
float fVar = Float.parseFloat("12.3");
// Store 12.3 in fVar.
double dVar = Double.parseDouble("7945.6");
// Store in dVar.
From Gaddis – Chapter 2 – slide 12

4. Review of the following Topics
The if Statement
The if-else Statement
The if-else-if Statement
Nested if Statements
Logical Operators
Comparing String Objects
More about Variable Declaration and Scope
The switch Statement
From Gaddis – Chapter 3 – slides 4 and 5

5. The if Statement
The if statement is one of a group of statements known as selection statements.
The if statement allows the programmer to make decisions whether a section of code executes or not. (i.e. does the program select these statements or not?)
The if statement uses a boolean expression OR a boolean variable as an argument to decide if the next statement or block of statements executes.
if (boolean expression is true) {
execute what’s in this block }
if (boolean_variable)
From Gaddis – Chapter 3 – slides 6 modified

6. Relational Operators
Relational Operator
Meaning
>
is greater than
<
is less than
>=
is greater than or equal to
<=
is less than or equal to ==
is equal to !=
is not equal to
Shown above are the 6 relational operators with their meanings
They are frequently used as boolean expressions in if statements.

7. *** Important ***
The result of the evaluation of a boolean expression is a boolean value.
if (7 > 5)
{ System.out.println ( “7 is bigger than 5);}
A boolean variable also has a boolean value.
boolean done;
done = true;
if (done)
{ System.out.println (“ done”); }
In an if statement a boolean variable is either true or false so we never compare it to true or false.

8. If Statement Programming Style
What is to be done when an if statement is true or false follows the condition. Although it is legal, we will NEVER put it on the same line.
if(average > 95)
System.out.println(“That’s a great score!”);
Multiple statements are grouped into a block by using curly braces {} to enclose them.
if(expression) {
statement1;
statement2;
statement3; }
Remember that if the curly braces are not used, then only the next statement after the if condition will be executed conditionally.

9. Use of Flags
A flag is a boolean variable that monitors some condition in a program.
When a condition is true, the flag is set to a true value.
The flag can be set to indicate a situation if(average > 95)
highScore = true;
The state of the flag can be tested:
if(highScore)
System.out.println(“That’s a high score!);

10. Comparing Characters
Characters can be tested using the relational operators.
Characters are stored in the computer using the unicode character format.
Each unicode character is stored using sixteen (16) bits.
Characters are ordinal, meaning they have an order in the unicode character set.
Since characters are ordinal, they can be compared to each other.

11. Digression Discussion of meaning of ordinal
Not only ordered but we know what the next element is.
for integers, given x, the next value is x+1 (integers are ordinal numbers)
for floating point numbers, given x.y, the next value is not known, could be x.y1 or x.y01, or x.y001 or … (floating point numbers are not ordinals)

12. if-else Statements
The if-else statement adds the ability to conditionally execute code based if the expression of the if statement is false.
if-else-if statements can become very complex.
if it is very cold, wear a heavy coat,
else, if it is chilly, wear a light jacket,
else, if it is windy wear a windbreaker,
else, if it is hot, wear no jacket.
Care must be used since else statements match up with the immediately preceding unmatched if statement.

13. Digression Discussion of Sign magnitude representation
Ones complement representation
Twos complement representation

14. Nassi-Shneiderman Diagrams

15. if-else-if Flowchart

16. Nested if Statements
If an if statement appears inside of another if statement (single or block) it is called a nested if statement.
The nested if is only executed if the if statement it is in results in a true condition.
Nested if statements can get very complex, very quickly.

17. Logical Operators
Java provides two binary logical operators (&& and ||) that are used to combine boolean expressions.
Java also provides one unary (!) logical operator to reverse the truth of a boolean expression.

18. Logical Operators Operator Meaning Effect && AND
Connects two boolean expressions into one. Both expressions must be true for the overall expression to be true. || OR
Connects two boolean expressions into one. One or both expressions must be true for the overall expression to be true. It is only necessary for one to be true, and it does not matter which one. !
NOT
The ! operator reverses the truth of a boolean expression. If it is applied to an expression that is true, the operator returns false. If it is applied to an expression that is false, the operator returns true.

19. The && Operator
The logical AND operator (&&) takes two operands that must both be boolean expressions.
The resulting combined expression is true iff (if and only if) both operands are true.
Expression 1
Expression 2
Expression1 && Expression2
true
false

20. The || Operator
The logical OR operator (||) takes two operands that must both be boolean expressions.
The resulting combined expression is false iff (if and only if) both operands are false.
Expression 1
Expression 2
Expression1 || Expression2
true
false

21. The ! Operator The ! operator performs a logical NOT operation.
If an expression is true, !expression will be false.
if (!(temperature > 100))
System.out.println(“Below the maximum temperature.");
Expression 1
!Expression1
true
false

22. DeMorgan’s Law The negation of (A and B) is (not A or not B)
(A or B) is (not A and not B)

23. Short Circuiting
Logical AND and logical OR operations perform short-circuit evaluation of expressions.
Logical AND will evaluate to false as soon as it sees that one of its operands is a false expression.
Logical OR will evaluate to true as soon as it sees that one of its operands is a true expression.

24. Order of Precedence
The ! operator has a higher order of precedence than the && and || operators.
The && and || operators have a lower precedence than relational operators like < and >.
Parenthesis can be used to force the precedence to be changed.

25. Order of Precedence Order of Precedence Operators Description 1
(unary negation) !
Unary negation, logical NOT 2
* / %
Multiplication, Division, Modulus 3
+ -
Addition, Subtraction 4
< > <= >=
Less-than, Greater-than, Less-than or equal to, Greater-than or equal to 5
== !=
Is equal to, Is not equal to 6
&&
Logical AND 7 ||
Logical NOT 8
= += -=
*= /= %=
Assignment and combined assignment operators.

26. Comparing String Objects
In most cases, you cannot use the relational operators to compare two String objects.
Reference variables contain the address of the object they represent.
Unless the references point to the same object, the relational operators will not return true.

27. Ignoring Case in String Comparisons
In the String class the equals and compareTo methods are case sensitive.
In order to compare two String objects that might have different case, use: …

28. Variable Scope
In Java, a local variable does not have to be declared at the beginning of the method.
The scope of a local variable begins at the point it is declared and terminates at the end of the method.
When a program enters a section of code where a variable has scope, that variable has come into scope, which means the variable is visible to the program.

29. The switch Statement
The if-else statements allow the programmer to make true / false branches.
The switch statement allows the programmer to use an ordinal value to determine how a program will branch.
The switch statement can evaluate an integer type or character type variable and make decisions based on the value.

30. The switch Statement The switch statement takes the form:
switch (SwitchExpression) {
case CaseExpression:
// place one or more statements here
break;
// case statements may be repeated
//as many times as necessary
default: }

31. The switch Statement
The switch statement takes an ordinal value (byte, short, int, long, char) as the SwitchExpression.
switch (SwitchExpression) { … }
The switch statement will evaluate the expression.
If there is an associated case statement that matches that value, program execution will be transferred to that case statement.

32. The switch Statement
Each case statement will have a corresponding CaseExpression that must be unique.
case CaseExpression:
// place one or more statements here
break;
If the SwitchExpression matches the CaseExpression, the Java statements between the colon and the break statement will be executed.

33. The switch Case The break statement ends the case statement.
The break statement is optional.
If a case does not contain a break, then program execution continues into the next case.
The default case is optional and will be executed if no CaseExpression matches the SwitchExpression.