if Statement

// ── Basic syntax: ────────────────────────────────────────────────────
//
//  if (condition) {
//      // statements executed only when condition is true
//  }
//  // execution always continues here

// ── Simple example: ───────────────────────────────────────────────────
int temperature = 35;

if (temperature > 30) {
    System.out.println("It is hot outside.");   // executes — 35 > 30
}
System.out.println("Check complete.");          // always executes

// ── Condition is false — block skipped: ──────────────────────────────
int temperature2 = 20;

if (temperature2 > 30) {
    System.out.println("It is hot outside.");   // SKIPPED — 20 > 30 is false
}
System.out.println("Check complete.");          // executes

// ── Multiple statements in the block: ────────────────────────────────
int speed = 90;
int speedLimit = 80;

if (speed > speedLimit) {
    int excess = speed - speedLimit;
    System.out.println("Speeding by " + excess + " km/h.");
    System.out.println("Fine issued.");
    System.out.println("Points added to licence.");
}

// ── Single statement without braces (avoid in practice): ─────────────
int age = 20;
if (age >= 18)
    System.out.println("Adult");        // works but risky

// WHY braces matter — classic bug:
if (age >= 18)
    System.out.println("Adult");
    System.out.println("Can vote.");    // NOT part of if — always executes!
//                                        looks like it is inside the if,
//                                        but indentation is just cosmetic.

// CORRECT — always use braces:
if (age >= 18) {
    System.out.println("Adult");
    System.out.println("Can vote.");    // now correctly inside the if
}

// ── Comparison operators — produce boolean: ──────────────────────────
int x = 10, y = 20;

if (x == y)  { System.out.println("Equal"); }
if (x != y)  { System.out.println("Not equal"); }       // executes
if (x <  y)  { System.out.println("Less than"); }       // executes
if (x <= y)  { System.out.println("Less or equal"); }   // executes
if (x >  y)  { System.out.println("Greater than"); }
if (x >= y)  { System.out.println("Greater or equal"); }

// ── Logical operators — combine booleans: ─────────────────────────────
int score = 75;
boolean passed = true;

if (score >= 60 && passed) {
    System.out.println("Eligible for certificate"); // both must be true
}

if (score < 50 || !passed) {
    System.out.println("Must retake the course");   // either condition true
}

// ── Boolean variable directly as condition: ───────────────────────────
boolean isLoggedIn = true;

if (isLoggedIn) {                   // same as: if (isLoggedIn == true)
    System.out.println("Welcome back!");
}

if (!isLoggedIn) {                  // same as: if (isLoggedIn == false)
    System.out.println("Please log in.");
}

// ── Method return values as conditions: ───────────────────────────────
String name = "Alice";
List<String> items = new ArrayList<>();

if (name.isEmpty()) {
    System.out.println("Name is empty");
}

if (name.startsWith("A")) {
    System.out.println("Name starts with A");       // executes
}

if (items.isEmpty()) {
    System.out.println("Cart is empty");            // executes
}

// ── Common mistake — assignment instead of comparison: ────────────────
boolean flag = false;
// if (flag = true) { }    // COMPILE ERROR in Java (unlike C++)
// Java prevents accidental assignment in conditions.
if (flag == true) { }      // correct comparison
if (flag) { }              // idiomatic — preferred

// ── AND (&&) — both conditions must be true: ─────────────────────────
int age   = 25;
boolean hasLicence = true;

if (age >= 18 && hasLicence) {
    System.out.println("Can drive");    // executes
}

// ── OR (||) — at least one condition must be true: ────────────────────
boolean isWeekend = false;
boolean isHoliday = true;

if (isWeekend || isHoliday) {
    System.out.println("Day off!");     // executes — isHoliday is true
}

// ── NOT (!) — inverts the condition: ─────────────────────────────────
boolean isRaining = false;

if (!isRaining) {
    System.out.println("Go for a walk"); // executes — !false = true
}

// ── Short-circuit evaluation — right side not evaluated if unnecessary: ─
String text = null;

// Safe — null check first: if text is null, .length() is never called:
if (text != null && text.length() > 5) {
    System.out.println("Long text");
}

// Unsafe — NullPointerException if text is null:
// if (text.length() > 5 && text != null) { }   // NPE before null check!

// ── Complex compound condition — use parentheses for clarity: ─────────
int salary   = 50000;
int yearsExp = 5;
boolean hasDegree = true;

if ((salary > 40000 && yearsExp >= 3) || hasDegree) {
    System.out.println("Eligible for senior role");
}

// ── Readability tip — extract complex conditions to named variables: ──
boolean sufficientExperience = yearsExp >= 3 && salary > 40000;
boolean qualifiedByEducation = hasDegree;

if (sufficientExperience || qualifiedByEducation) {
    System.out.println("Eligible for senior role");  // same result, clearer
}

// ── Input validation: ────────────────────────────────────────────────
public void setAge(int age) {
    if (age < 0 || age > 150) {
        throw new IllegalArgumentException(
            "Age must be between 0 and 150, got: " + age);
    }
    this.age = age;
}

// ── Null safety: ──────────────────────────────────────────────────────
public String getDisplayName(User user) {
    if (user == null) {
        return "Guest";
    }
    if (user.getName() == null || user.getName().isBlank()) {
        return "Anonymous";
    }
    return user.getName();
}

// ── Range checking: ───────────────────────────────────────────────────
public String classifyBMI(double bmi) {
    if (bmi < 18.5) {
        return "Underweight";
    }
    if (bmi < 25.0) {
        return "Normal weight";
    }
    if (bmi < 30.0) {
        return "Overweight";
    }
    return "Obese";
    // Note: no else needed — each if returns early.
    // This is the "guard clause" or "early return" pattern.
}

// ── Business rule: ────────────────────────────────────────────────────
public double calculateDiscount(Customer customer, double orderTotal) {
    double discount = 0.0;

    if (customer.isPremium()) {
        discount = 0.15;    // 15% for premium customers
    }

    if (orderTotal > 500.0) {
        discount += 0.05;   // extra 5% for large orders
    }

    if (customer.hasCoupon()) {
        discount += 0.10;   // extra 10% with coupon
    }

    return discount;
}

// ── Checking collection state: ────────────────────────────────────────
public void processOrder(List<OrderItem> items) {
    if (items == null) {
        throw new IllegalArgumentException("Items list cannot be null");
    }
    if (items.isEmpty()) {
        System.out.println("No items to process.");
        return;
    }
    // process items...
    System.out.println("Processing " + items.size() + " items.");
}