{"title":"If-Else Statements","description":"","content":"Programs constantly have to make decisions: charge tax or not, apply a discount or skip it, show a \"free shipping\" banner or hide it. The `if` statement is the most basic tool Java gives you for branching on a condition. This lesson covers `if`, `if/else`, `else if` chains, and the nested form, along with common bugs to watch for.\n\n---\n\n# The Basic `if` Statement\n\nAn `if` statement runs a block of code only when a boolean condition is `true`. If the condition is `false`, the block is skipped and execution continues with whatever comes next.\n\n\n```java\npublic class FreeShippingBanner {\n public static void main(String[] args) {\n double cartTotal = 75.00;\n if (cartTotal >= 50) {\n System.out.println(\"You qualify for free shipping!\");\n }\n System.out.println(\"Cart total: $\" + cartTotal);\n }\n}\n```\n\n\nThe condition has to be a `boolean` expression. Anything that produces `true` or `false` works: a relational comparison like `cartTotal >= 50`, a boolean variable, a method call that returns `boolean`, or a combination of these. Unlike some other languages, Java will not accept a number or a `String` where a boolean is expected. Writing `if (cartTotal)` is a compile error.\n\nThe curly braces around the block are optional when the body is a single statement, but you should always use them anyway. A missing brace is the source of one of the oldest bugs in C-family languages:\n\n\n```java\ndouble cartTotal = 30.0;\nif (cartTotal >= 50)\n System.out.println(\"Free shipping!\");\n System.out.println(\"Thanks for shopping\");\n```\n\n\nThat second `println` is always executed, no matter what `cartTotal` is, because only the next single statement belongs to the `if`. The indentation lies. Add braces and the bug goes away.\n\n---\n\n# `if/else`\n\nTo do one thing when a condition is true and a different thing when it's false, use `else`. The `else` block runs only when the `if` condition is `false`, never both.\n\n\n```java\npublic class CheckoutMessage {\n public static void main(String[] args) {\n int cartItems = 0;\n if (cartItems > 0) {\n System.out.println(\"Proceed to checkout\");\n } else {\n System.out.println(\"Your cart is empty\");\n }\n }\n}\n```\n\n\n`if/else` is used constantly: applying or skipping a discount, showing one of two banners, returning one of two values from a method. It's the simplest form of a two-way decision.\n\nA larger example combines a few conditions using `&&` and `||`. The combined expression still produces a single boolean, which is all `if` cares about.\n\n\n```java\npublic class CouponEligibility {\n public static void main(String[] args) {\n double cartTotal = 120.0;\n boolean isPremiumCustomer = false;\n if (cartTotal >= 100 || isPremiumCustomer) {\n System.out.println(\"Coupon applied: 10% off\");\n } else {\n System.out.println(\"Add more to qualify for a coupon\");\n }\n }\n}\n```\n\n\n---\n\n# `else if` Chains\n\nWhen you have more than two outcomes, chain `else if` clauses together. Java evaluates the conditions top to bottom, runs the first block whose condition is `true`, and skips the rest. The optional final `else` is the fallback for the case where none of the conditions matched.\n\n\n```java\npublic class CustomerTier {\n public static void main(String[] args) {\n double yearlySpend = 850.0;\n String tier;\n if (yearlySpend >= 2000) {\n tier = \"Platinum\";\n } else if (yearlySpend >= 1000) {\n tier = \"Gold\";\n } else if (yearlySpend >= 500) {\n tier = \"Silver\";\n } else {\n tier = \"Bronze\";\n }\n System.out.println(\"Tier: \" + tier);\n }\n}\n```\n\n\nThe order of conditions matters. Java stops checking as soon as one matches. With `yearlySpend = 850`, the first two conditions are `false`, the third is `true`, so `tier` becomes `\"Silver\"` and the chain ends. The fourth branch isn't even evaluated.\n\nThat short-circuit behavior is also why the chain works correctly with overlapping ranges. The first check is `>= 2000`, the next is `>= 1000`. A value of `1500` would satisfy both, but only the first matching branch runs. If you reversed the order and put `>= 500` at the top, every spend over $500 would be classified as Silver and the higher tiers would never trigger.\n\nThe flow of that decision visualized:\n\n\n```mermaid\nflowchart TD\n Start([yearlySpend]):::cyan --> C1{>= 2000?}:::orange\n C1 -- Yes --> P[Platinum]:::green\n C1 -- No --> C2{>= 1000?}:::orange\n C2 -- Yes --> G[Gold]:::green\n C2 -- No --> C3{>= 500?}:::orange\n C3 -- Yes --> S[Silver]:::teal\n C3 -- No --> B[Bronze]:::red\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef red fill:#ff8787,stroke:#000,color:#000\n```\n\n\nEach diamond is a check. The first one that answers \"yes\" determines the tier; the rest are never reached.\n\n---\n\n# Nested `if`\n\nYou can put an `if` inside another `if`. The inner statement only runs when the outer condition is `true`, which lets you express conditions that depend on each other.\n\n\n```java\npublic class DiscountCalculator {\n public static void main(String[] args) {\n double cartTotal = 150.0;\n boolean hasCoupon = true;\n double discount = 0;\n\n if (cartTotal >= 100) {\n if (hasCoupon) {\n discount = cartTotal * 0.20;\n } else {\n discount = cartTotal * 0.10;\n }\n }\n System.out.println(\"Discount: $\" + discount);\n }\n}\n```\n\n\nThe inner `if/else` only runs when `cartTotal >= 100`. If the outer condition is `false`, `discount` stays at `0` and neither inner branch executes.\n\nNesting works, but it gets ugly fast. Two levels are usually fine. Three levels are a code smell. The example above can be rewritten without nesting by combining conditions with `&&`:\n\n\n```java\npublic class DiscountCalculatorFlat {\n public static void main(String[] args) {\n double cartTotal = 150.0;\n boolean hasCoupon = true;\n double discount = 0;\n\n if (cartTotal >= 100 && hasCoupon) {\n discount = cartTotal * 0.20;\n } else if (cartTotal >= 100) {\n discount = cartTotal * 0.10;\n }\n System.out.println(\"Discount: $\" + discount);\n }\n}\n```\n\n\nSame result, easier to read. The rule of thumb: if the inner condition logically belongs with the outer one, combine them with `&&` or build an `else if` chain. Save real nesting for cases where the inner check is in a different category from the outer one (for example, \"if the customer is logged in, check their cart state\").\n\n---\n\n# The Dangling Else\n\nWhen you write nested `if/else` without braces, an `else` always binds to the nearest unmatched `if`, no matter how you indent it. This is the **dangling else** problem.\n\n**What's wrong with this code?**\n\n\n```java\nint cartItems = 2;\nboolean hasCoupon = false;\nif (cartItems > 0)\n if (hasCoupon)\n System.out.println(\"Coupon applied\");\nelse\n System.out.println(\"Cart is empty\");\n```\n\n\nThe indentation suggests the `else` belongs to the outer `if`, which would mean nothing prints (`cartItems > 0` is `true`, `hasCoupon` is `false`, no message about an empty cart). What actually happens: the `else` binds to the inner `if (hasCoupon)`, so the code prints `Cart is empty` even though the cart has 2 items.\n\n**Fix:**\n\n\n```java\npublic class DanglingElseFixed {\n public static void main(String[] args) {\n int cartItems = 2;\n boolean hasCoupon = false;\n if (cartItems > 0) {\n if (hasCoupon) {\n System.out.println(\"Coupon applied\");\n }\n } else {\n System.out.println(\"Cart is empty\");\n }\n }\n}\n```\n\n\nThe output is empty because `cartItems > 0` is `true` (so the outer `else` is skipped) and `hasCoupon` is `false` (so the inner block is skipped). Braces make the binding explicit and remove the ambiguity entirely. This is the single best reason to always use braces, even when the language lets you skip them.\n\n---\n\n# Common Bugs\n\nSeveral bugs show up in `if` statements repeatedly. They're easy to fix once recognized.\n\n### `=` Instead of `==`\n\n`=` is assignment. `==` is the equality check. Most languages accept `if (x = 5)` and assign `5` to `x` before checking if the result is truthy. Java prevents this when the variable is numeric: `if (orderCount = 5)` does not compile, because the assignment evaluates to an `int` and `if` requires a `boolean`.\n\nThe protection breaks down when the variable itself is `boolean`.\n\n**What's wrong with this code?**\n\n\n```java\nboolean isPremiumCustomer = false;\nif (isPremiumCustomer = true) {\n System.out.println(\"Premium discount applied\");\n}\nSystem.out.println(\"isPremiumCustomer = \" + isPremiumCustomer);\n```\n\n\nThis compiles. `isPremiumCustomer = true` assigns `true` to the variable, the expression evaluates to `true`, the block always runs, and now `isPremiumCustomer` is mutated as a side effect. Three things go wrong at once.\n\n**Fix:**\n\n\n```java\npublic class EqualityCheckFix {\n public static void main(String[] args) {\n boolean isPremiumCustomer = false;\n if (isPremiumCustomer == true) {\n System.out.println(\"Premium discount applied\");\n }\n System.out.println(\"isPremiumCustomer = \" + isPremiumCustomer);\n }\n}\n```\n\n\nEven cleaner: drop the redundant comparison and write `if (isPremiumCustomer)`. A boolean variable already is the condition.\n\n### Comparing Strings with `==`\n\n`==` on strings compares references, not contents. Two strings that look identical can sit at different addresses in memory, in which case `==` returns `false`. Use `.equals()` for content comparison.\n\n**What's wrong with this code?**\n\n\n```java\nString orderStatus = new String(\"SHIPPED\");\nif (orderStatus == \"SHIPPED\") {\n System.out.println(\"Your order is on the way\");\n} else {\n System.out.println(\"Status: \" + orderStatus);\n}\n```\n\n\nBecause `new String(\"SHIPPED\")` forces a fresh object, `orderStatus` and the string literal `\"SHIPPED\"` are different references. The `==` check is `false`, so the `else` branch runs.\n\n**Fix:**\n\n\n```java\npublic class StringEqualityFix {\n public static void main(String[] args) {\n String orderStatus = new String(\"SHIPPED\");\n if (orderStatus.equals(\"SHIPPED\")) {\n System.out.println(\"Your order is on the way\");\n } else {\n System.out.println(\"Status: \" + orderStatus);\n }\n }\n}\n```\n\n\nThe rule: compare strings with `.equals()`.\n\n---\n\n# When to Use `if/else` vs `switch`\n\nAn `else if` chain handles any condition you can write as a boolean. A `switch` statement is more restricted: it picks among the values of a single expression, comparing them for equality.\n\nUse `if/else` when:\n\n- The conditions test ranges (`yearlySpend >= 1000`).\n- The conditions involve different variables (`cartTotal > 100 && hasCoupon`).\n- The conditions are arbitrary boolean expressions.\n\nUse `switch` when:\n\n- You're comparing one variable against several fixed values.\n- The values are constants like `int`, `String`, or enum constants.\n\nFor example, the tier code earlier (`>= 2000`, `>= 1000`, `>= 500`) is range-based, so `if/else` fits. But classifying an order status (`\"PLACED\"`, `\"SHIPPED\"`, `\"DELIVERED\"`, `\"CANCELLED\"`) is equality against fixed values, which is what `switch` was built for.","pageType":"java"}

If-Else Statements

Get Premium