Conditional Statements

• Flow of control refers to the order in which a program executes actions.
• Branching statements enable programs to choose between two or more possible actions.
• Loop statements allow programs to repeat an action until a specific stopping condition is met.

The if-else Statement

• A branching statement that selects between two potential actions
• The syntax consists of an if keyword, a boolean expression in parentheses, Statement_1, an else keyword, and Statement_2.
• If the Boolean_Expression evaluates to true, Statement_1 is executed; otherwise, Statement_2 is executed.

Compound Statements

• To include multiple statements within a branch, they must be enclosed in braces {} to form a compound statement.
• Compound statements can be used anywhere a single statement is allowed.

Omitting the else Part

• The else part can be omitted such if (Boolean_Expression) Statement, and if the expression evaluates to false, no action is performed.

Boolean Expressions

• A boolean expression is an expression that can only evaluate to either true or false.
• Boolean expressions are used in if statements and loops to determine control flow
• Examples of boolean expressions include comparisons such as time < limit and balance <= 0.

Java Comparison Operators

• == (Equal to): Evaluates if two operands are equal.
• != (Not equal to): Evaluates if two operands are not equal.
• > (Greater than): Evaluates if the left operand is greater than the right operand.
• >= (Greater than or equal to): Evaluates if the left operand is greater than or equal to the right operand.
• < (Less than): Evaluates if the left operand is less than the right operand.
• <= (Less than or equal to): Evaluates if the left operand is less than or equal to the right operand.

Compound Boolean Expressions

• Boolean expressions can be combined using logical operators such as "and" (&&) and "or" (||).
• (Sub_Expression_1) && (Sub_Expression_2) is true only if both sub-expressions are true.
• (Sub_Expression_1) || (Sub_Expression_2) is true if either of the sub-expressions is true.
• Java uses inclusive or, meaning the expression is true if either one or both expressions are true.
• Exclusive or is true if one or the other is true, but not both.

Boolean Negation

• Boolean negation is performed using the "not" operator !.
• !Boolean_Expression inverts the value of the expression (if it's true, it becomes false, and vice versa).

Truth Tables

| A | B | A && B | A || B | | :---- | :---- | :----- | :----- | | true | true | true | true | | true | false | false | true | | false | true | false | true | | false | false | false | false |

Primary Logical Operators

• AND, OR, and NOT are primary logical operators.
• Any logical expression can be composed using these operators.
• The exclusive or operation can be expressed as (a || b) && !(a && b).

Using ==

• The == operator checks if two integers or characters have the same value.
• However, it’s not the best approach for floating-point numbers due to precision issues but you can use tolerance
• == is not appropriate for testing if two objects have the same value.

Comparing Strings

• To test the equality of String objects, the equals method should be used such as s1.equals(s2)
• For equality checks ignoring case, use equalsIgnoreCase such "Hello".equalsIgnoreCase("hello").

Lexicographic Order

• Lexicographic order is similar to alphabetical order but based on the order of characters.
• All digits come before letters.
• All uppercase letters come before lowercase letters.

Method compareTo

• The compareTo method is used to compare strings of alphabetic character.
• String_1.compareTo(String_2) method returns
  • a negative number if String_1 precedes String_2.
  • zero if the two strings are equal.
  • a positive number if String_2 precedes String_1.

Comparing Numbers vs. Comparing Strings

Nested Statements

• if-else statements can be nested inside other if-else statements.
• An if-else statement can be nested within "if" part, the "else" part, or both parts.
• Each else is paired with the nearest unmatched if.
• Indentation improves readability but doesn't affect how the compiler interprets the code.

Multibranch if-else Statements

• Provides multiple exclusive branches based on different conditions.
• Uses a chain of if and else if statements, ending with an optional else for a default case.

The switch Statement

• switch statements are a multiway branch that takes a decision based on an integral expression.
• The switch statement consists of the keyword switch followed by an integral expression in parentheses, known as a controlling expression.
• The default case is optional but recommended even if it prints a message.
• Repeated cases are not allowed
• The action for each case typically ends with break
• break statements prevent the consideration of other cases

Conditional Operator

• Shorthand way of writing if-else statements, also known as a ternary operator.
• max = (n1 > n2) ? n1 : n2; the whole expression has a value unlike if-else statement
• Can be particularly useful in print statements for concise conditional output.

Summary of Branching

• Primary Java branching statements include:
  • if statement (1 or 2 branches)
  • Multi-branch if-else-if statement (3 or more branches)
  • Multi-branch switch statement
  • Conditional operator ?:

Loop Statements

• A loop repeats a statement or group of statements.
• The statement or group of statements to be repeated is the body of the loop.
• There must be a means of exiting the loop.
• Control of loop consist of Initialization, Condition for termination (continuing), and Updating the condition

The while Statement

• Also called a while loop continuously executes a block of code as long as a given boolean expression is true.
• If the boolean expression is initially false, the loop may not execute at all.

The do-while Statement

• Similar to a while loop.
• The loop body is executed at least once.
• Its syntax is do Body_Statement while (Boolean_Expression);.

for Statement

• It also called a for loop will execute based on a fixed number of times
• for (Initialization; Condition; Update), Initialization; is where the for loop will receive some initial value, Condition is the expression to validate and update is where the initial value can eventually be increased or decremented based on some statement

Programming Example: Bug Infestation

• Demonstrates using loops to model population growth.
• Given parameters are the volume of a roach, starting population, rate of increase, and volume of a house calculates the number of weeks to exceed capacity.

Infinite Loops

• A loop that never terminates because its controlling boolean expression never becomes false.
• Can be caused by incorrect loop conditions or failure to update variables properly.

Multiple Initialization

• In for loops multiple initialization and update action are valid
• Only one boolean expression is allowed

Choosing a Loop Statement

• Use a for loop if the number of iterations is known.
• Use a while loop if the number of iterations isn't known and the loop might not execute.
• Use a do-while loop if the loop must execute at least once.
• Generally, a while loop is a safe choice.

break Statement in Loops

• break statements can prematurely terminate a loop.
• Always try to end a loop at only one place; break statements makes debugging hard.

exit Method

• System.exit(0) to terminate the program; example such when there are no winners.

Programming with Loops

• Outlines best practices for loop design:
  • Design the loop body first, identifying repeated actions.
  • Initialize variables before the loop.
  • Ensure the loop terminates correctly using sentinel values or other techniques.
  • Watch out for loop-bugs such infinite loops, off-by-one errors, testing equality of floating-point numbers
  • Then trace variables

Loop Bugs

• Common loop errors include:
  • Unintended infinite loops: These occur when the loop condition never becomes false, causing the loop to run indefinitely.
  • Off-by-one errors: These happen when the loop iterates one too many or one too few times.
  • Testing equality of floating-point numbers: Due to precision issues, directly comparing floating-point numbers for equality can lead to unexpected results and infinite loops.

Off-by-One Errors

• The loop body will be repeated one too many or too few times

Subtle Infinite Loops

• A subtle case is a situation where the payment is never enough; check if payment is less than or equal to penalty if (payment <= penalty) System.out.println(“payment is too small”);

Empty for Statement

• for (number = 1; number <= 10; number++); , a common bug where the for loop is left hanging.

Testing Equality of Floating-point Numbers

• "==" operator works normally with integers but can be a problem with floating-point numbers

Tracing Variables

• Debugging the code includes simply inserting temporary output statements to see what's broken.

Type boolean

• type boolean can either be true or false.
• They can be assigned the result of a boolean expression.
• Good boolean variable names are in isPositive or systemsAre0k form and bad forms are systemsStatus; name it based on what it really means

Precedence Rules

• In the absence of parentheses to explicitly specify the order, Java operations follow precedence rules:
  • Operations with higher precedence are performed before operations with lower precedence.
  • Operations with the same precedence are done left to right.

Short-circuit Evaluation

• In && (AND), if the first one is false then return false
• In || (OR), if the first one is true then return true
• This is called short-circuit or lazy evaluation.

Input and output boolean values

• boolean boo = false;
• and use System.out.println to print it

Using a Boolean Variable to End a Loop

• numbersLeftToRead is an example of how boolean variables can be used to end a loop
  • next = keyboard.nextInt(); if (next < 0) numbersLeftToRead = false;
• when the value of keyboard is less than 0, that triggers the numbersLeftToRead to become false thus ending said loop