Crash Course — Unit 2: Selection and Iteration

• Boolean Expressions — The true or false questions that guide your program's decisions, like score > 90.
• Relational Operators — The tools (==, !=, <, >, <=, >=) you use to build Boolean expressions by comparing values.
• if-else if-else Statements — The fundamental structure for making your code choose one path out of many possible options.
• Compound Boolean Expressions (&&, ||, !) — Combining simple questions with AND, OR, and NOT to ask more complex ones, like isRaining && isCold.
• Short-Circuit Evaluation — Java's clever way of saving time; it stops evaluating a compound expression (&& or ||) as soon as it knows the final answer.
• De Morgan's Laws — A specific way to rewrite and simplify compound Boolean expressions, often tested on the multiple-choice section.
• Object Comparison (== vs. .equals()) — A critical distinction. == checks if two variables point to the exact same object in memory, while .equals() checks if their contents are meaningfully the same.

• while Loops — Repeats a block of code as long as a condition remains true. Use when you don't know the exact number of repetitions ahead of time.
• for Loops — Repeats a block of code a specific number of times. The go-to loop for iterating over a known range or a String's length.
• String Traversal — Using a for loop to visit and inspect every single character in a String, one by one.
• Nested Loops — Placing one loop inside another. This is your tool for working with 2D data, like a grid of seats in a stadium or pixels on a screen.
• Statement Execution Count — A simple way to analyze an algorithm's efficiency by counting how many times a key statement runs as the input gets larger.

Key Formulas / Terms

• if-else if-else Structure:

  if (condition1) {
    // Do this
  } else if (condition2) {
    // Do this instead
  } else {
    // Do this if nothing above was true
  }

• De Morgan's Laws:
  • !(A && B) is equivalent to !A || !B
  • !(A || B) is equivalent to !A && !B
• Standard for Loop (for counting):

  for (int i = 0; i < count; i++) {
    // This code runs 'count' times
  }

• Standard while Loop (until a condition is met):

  int ticketsSold = 0;
  while (ticketsSold < 100) {
    // Sell a ticket...
    ticketsSold++; // CRITICAL: Update the variable!
  }

• String Traversal Loop:

  String message = "Hello";
  for (int i = 0; i < message.length(); i++) {
    System.out.println(message.charAt(i));
  }

• Object vs. Primitive Comparison:
  • int a = 5; int b = 5; -> a == b is true.
  • String s1 = new String("hi"); String s2 = new String("hi"); -> s1 == s2 is false, but s1.equals(s2) is true.

Exam Traps

• Trap
  = vs. ==. Using a single equals sign (=) for assignment inside an if statement's condition, when you meant to use the double equals (==) for comparison. · Counter: Always double-check your if conditions. Your compiler will often catch this, but on paper, it's an easy mistake to make and a common wrong answer choice.
• Trap
  Off-by-One Errors. Your loop runs one too many or one too few times. This usually happens when you mix up < and <=, or start your loop index at 1 instead of 0. · Counter: For a String of length(), the valid indices are 0 to length() - 1. Your loop condition should almost always be i < str.length().
• Trap
  Comparing Objects with ==. The exam will show you two String or other objects created with new and ask if obj1 == obj2 is true. It's almost always false. · Counter: Internalize this now: == checks for the same memory location (are they the exact same object?). .equals() checks for the same content (do they look the same?). For Strings, always use .equals() to compare their values.
• Trap
  Dangling else. In a nested if structure, an else statement can look like it belongs to the outer if, but it doesn't. · Counter: Remember the rule: an else always pairs with the nearest, preceding if that isn't already paired with an else. Use curly braces {} to make your intention clear, even when they aren't strictly required.
• Trap
  Infinite while Loops. You write a while loop but forget to include the code inside the loop that will eventually make the condition false. · Counter: Before you finish writing a while loop, ask yourself: "What line of code inside this loop is making progress toward the exit?" Make sure you update the variable that's being checked in the condition.