Java Ternary Operator — The $0.01 Accumulation Bug

public class TernaryBasics {
    public static void main(String[] args) {

        int temperature = 35; // degrees Celsius

        // Traditional if-else — totally valid, just more lines
        String weatherAdvice_ifElse;
        if (temperature > 30) {
            weatherAdvice_ifElse = "Wear a hat and stay hydrated";
        } else {
            weatherAdvice_ifElse = "Enjoy the mild weather";
        }

        // Ternary operator — same logic, one line
        // Syntax: condition ? valueIfTrue : valueIfFalse
        String weatherAdvice_ternary = (temperature > 30)
                ? "Wear a hat and stay hydrated"   // condition is TRUE → use this
                : "Enjoy the mild weather";          // condition is FALSE → use this

        // Both variables hold the exact same value
        System.out.println("if-else result : " + weatherAdvice_ifElse);
        System.out.println("ternary result : " + weatherAdvice_ternary);

        // You can also use the ternary directly inside a method call
        int humidity = 80;
        System.out.println(
            "Humidity alert: " + (humidity > 70 ? "Very humid outside!" : "Comfortable humidity")
        );
    }
}

public class EcommerceLabels {
    public static void main(String[] args) {

        // --- Scenario 1: Shipping cost label ---
        double orderTotal = 75.00;
        double shippingThreshold = 50.00;

        // If the order exceeds the threshold, shipping is free — otherwise show the cost
        String shippingLabel = (orderTotal >= shippingThreshold) ? "FREE" : "$5.99";
        System.out.println("Shipping: " + shippingLabel);

        // --- Scenario 2: User membership status ---
        boolean isMember = true;

        // Pick the right badge to display next to the username
        String userBadge = isMember ? "⭐ Member" : "Guest";
        System.out.println("Account type: " + userBadge);

        // --- Scenario 3: Stock availability ---
        int stockCount = 0;

        // Any stock at all → show In Stock; zero stock → show Sold Out
        String stockStatus = (stockCount > 0) ? "In Stock" : "Sold Out";
        System.out.println("Product status: " + stockStatus);

        // --- Scenario 4: Ternary inside a calculation ---
        // Members get a 10% discount; guests pay full price
        double itemPrice = 120.00;
        double finalPrice = itemPrice * (isMember ? 0.90 : 1.00); // 10% off for members
        System.out.println("Final price: $" + finalPrice);
    }
}

public class GradeCalculator {
    public static void main(String[] args) {

        int examScore = 73;

        // --- One level of nesting: borderline acceptable ---
        // Read it as: above 89 → A, above 74 → B, otherwise → C (simplified)
        String letterGrade = (examScore >= 90) ? "A"
                           : (examScore >= 75) ? "B"
                           : "C";
        System.out.println("Grade (ternary): " + letterGrade);

        // --- The same logic as a readable if-else (prefer this for three+ branches) ---
        String letterGradeReadable;
        if (examScore >= 90) {
            letterGradeReadable = "A";
        } else if (examScore >= 75) {
            letterGradeReadable = "B";
        } else {
            letterGradeReadable = "C";
        }
        System.out.println("Grade (if-else): " + letterGradeReadable);

        // --- AVOID: deeply nested ternary — hard to read, easy to get wrong ---
        // Don't do this in production code unless you enjoy mystery
        // String grade = (s>=90)?"A":(s>=80)?"B":(s>=70)?"C":(s>=60)?"D":"F";
        // Use if-else chains or a switch expression instead for 4+ branches

        System.out.println("Both approaches give the same result: " +
            letterGrade.equals(letterGradeReadable));
    }
}

public class TernaryMistakes {
    public static void main(String[] args) {

        boolean isLoggedIn = true;
        int cartItemCount = 5;

        // ❌ MISTAKE 1: Using ternary to run a statement (won't compile)
        // isLoggedIn ? System.out.println("Welcome back!") : System.out.println("Please log in");
        // ERROR: void cannot be dereferenced — ternary expects a VALUE, not an action

        // ✅ FIX 1: Move the logic so the ternary picks a value, not an action
        String greeting = isLoggedIn ? "Welcome back!" : "Please log in";
        System.out.println(greeting); // Now println receives one string value

        // ❌ MISTAKE 2: Mixed types producing unexpected behaviour
        // Java will try to widen the int to a double here — sometimes surprising
        double deliveryFee = isLoggedIn ? 0 : 4.99;
        // Java sees int 0 and double 4.99 — it promotes 0 to 0.0 automatically
        // In this case the result is fine, but mixing String and numeric types will cause a compile error
        System.out.println("Delivery fee: $" + deliveryFee); // Prints 0.0, not 0

        // ✅ FIX 2: Be explicit with your types so the intent is crystal clear
        double deliveryFeeFixed = isLoggedIn ? 0.00 : 4.99; // Both sides are clearly doubles
        System.out.println("Delivery fee (explicit): $" + deliveryFeeFixed);

        // ❌ MISTAKE 3: Missing parentheses changing operator precedence
        // What does this actually calculate?
        int wrongResult = cartItemCount > 3 ? cartItemCount + 1 : cartItemCount - 1 * 2;
        // The * 2 binds tighter than the : separator — result is cartItemCount - (1*2) = 3
        System.out.println("Wrong result: " + wrongResult);

        // ✅ FIX 3: Use parentheses to make precedence unambiguous
        int correctResult = cartItemCount > 3 ? (cartItemCount + 1) : ((cartItemCount - 1) * 2);
        System.out.println("Correct result: " + correctResult);
    }
}

import java.util.*;
import java.util.stream.*;

public class ProductionGotchas {
    public static void main(String[] args) {

        // --- Performance myth: ternary vs if-else bytecode ---
        // Run with -XX:+PrintBytecode to see they compile identically

        // --- Ternary inside stream (hard to debug) ---
        List<Integer> items = Arrays.asList(1, 2, 3, 4, 5);
        String result = items.stream()
                .map(i -> i % 2 == 0 ? "even" : "odd")
                .collect(Collectors.joining(", "));
        System.out.println(result);
        // To debug, extract the lambda:
        // .map(i -> { return i % 2 == 0 ? "even" : "odd"; })
        // or use if-else inside the lambda

        // --- Auto-unboxing NPE risk ---
        Integer boxed = null;
        int val = 10;
        // int result2 = (true) ? val : boxed;  // Boxed is null → NPE when unboxed
        // Fix: use Integer for both sides
        Integer safeResult = (true) ? val : boxed;
        System.out.println("Safe: " + safeResult); // prints 10, no NPE
    }
}