Java Language Specification — Conditionals¶

// This code is ambiguous-looking but well-defined:
if (x > 0)
    if (y > 0)
        System.out.println("both positive");
else
    System.out.println("else");  // belongs to inner if (y > 0), NOT outer if
// Use braces to make intent clear

int day = 3;
switch (day) {
    case 1:
    case 2:
    case 3:
        System.out.println("Early week");  // falls through from 1 and 2
        break;
    case 4:
    case 5:
        System.out.println("Late week");
        break;
    default:
        System.out.println("Weekend");
}

int value = 2;
int result = switch (value) {
    case 1 -> 10;
    case 2 -> {
        int temp = value * 20;
        yield temp + 1;         // yield exits the block
    }
    default -> 0;
};
System.out.println(result);  // 41

sealed interface Animal permits Dog, Cat {}
record Dog(String name) implements Animal {}
record Cat(String name) implements Animal {}

Animal a = new Dog("Rex");
// Switch is exhaustive — no default needed
String sound = switch (a) {
    case Dog d -> "Woof from " + d.name();
    case Cat c -> "Meow from " + c.name();
};
System.out.println(sound);  // Woof from Rex

String s = null;
// Classic switch: NullPointerException
// switch (s) { case "a": ... }  // NPE at runtime

// Java 21 switch with null handling:
String result = switch (s) {
    case null -> "null value";
    case "a"  -> "letter a";
    default   -> "other";
};
System.out.println(result);  // null value

int a = 1;
double b = 2.0;
var result = true ? a : b;   // result type is double (a promoted to double)
System.out.println(result);  // 1.0

Object obj = true ? "hello" : 42;  // String or Integer → Object
System.out.println(obj.getClass().getSimpleName());  // String

// Example 1: if-else Fundamentals
// File: IfElseDemo.java
public class IfElseDemo {
    public static void main(String[] args) {
        // Basic if-else
        int score = 75;
        if (score >= 90) {
            System.out.println("A");
        } else if (score >= 80) {
            System.out.println("B");
        } else if (score >= 70) {
            System.out.println("C");
        } else {
            System.out.println("D");
        }
        // Output: C

        // Short-circuit in condition
        String str = null;
        if (str != null && str.length() > 0) {
            System.out.println("Non-empty string");
        } else {
            System.out.println("Null or empty");
        }
        // Output: Null or empty (no NPE due to &&)

        // Ternary operator
        int abs = score < 0 ? -score : score;
        System.out.println("abs: " + abs);

        // Nested ternary (right-associative)
        String category = score >= 90 ? "A"
                        : score >= 80 ? "B"
                        : score >= 70 ? "C"
                        : "D";
        System.out.println("Grade: " + category);
    }
}

// Example 2: Classic Switch Statement
// File: SwitchStatement.java
public class SwitchStatement {
    enum Day { MON, TUE, WED, THU, FRI, SAT, SUN }

    public static void main(String[] args) {
        // int switch
        int month = 4;
        int daysInMonth;
        switch (month) {
            case 1: case 3: case 5: case 7:
            case 8: case 10: case 12:
                daysInMonth = 31;
                break;
            case 4: case 6: case 9: case 11:
                daysInMonth = 30;
                break;
            case 2:
                daysInMonth = 28;  // ignoring leap years
                break;
            default:
                throw new IllegalArgumentException("Invalid month: " + month);
        }
        System.out.println("April has " + daysInMonth + " days");  // 30

        // String switch (Java 7+)
        String command = "start";
        switch (command) {
            case "start":
                System.out.println("Starting...");
                break;
            case "stop":
                System.out.println("Stopping...");
                break;
            default:
                System.out.println("Unknown command: " + command);
        }

        // Enum switch
        Day today = Day.WED;
        switch (today) {
            case SAT: case SUN:
                System.out.println("Weekend!");
                break;
            default:
                System.out.println("Weekday: " + today);
        }
    }
}

// Example 3: Switch Expressions (Java 14+)
// File: SwitchExpressions.java
public class SwitchExpressions {

    enum Season { SPRING, SUMMER, FALL, WINTER }

    public static void main(String[] args) {
        // Arrow-form switch expression (no fall-through)
        Season season = Season.SUMMER;
        String activity = switch (season) {
            case SPRING -> "Gardening";
            case SUMMER -> "Swimming";
            case FALL   -> "Hiking";
            case WINTER -> "Skiing";
        };
        System.out.println(activity);  // Swimming

        // Block-form with yield
        int temp = 35;
        String recommendation = switch (season) {
            case SUMMER -> {
                if (temp > 30) {
                    yield "Stay hydrated! " + temp + "°C";
                } else {
                    yield "Nice summer day";
                }
            }
            default -> "Enjoy the season";
        };
        System.out.println(recommendation);

        // Multiple labels per case
        int day = 6;
        boolean isWeekend = switch (day) {
            case 1, 7 -> true;
            default   -> false;
        };
        System.out.println("Is weekend: " + isWeekend);  // true

        // Switch expression as argument
        System.out.println("Months in " + season + ": " + switch (season) {
            case SPRING, SUMMER, FALL -> 3;
            case WINTER               -> 3;
        });
    }
}

// Example 4: Pattern Matching Switch (Java 21)
// File: PatternSwitch.java
public class PatternSwitch {

    sealed interface Shape permits Circle, Rectangle, Triangle {}
    record Circle(double radius) implements Shape {}
    record Rectangle(double width, double height) implements Shape {}
    record Triangle(double base, double height) implements Shape {}

    static double area(Shape shape) {
        return switch (shape) {
            case Circle c       -> Math.PI * c.radius() * c.radius();
            case Rectangle r    -> r.width() * r.height();
            case Triangle t     -> 0.5 * t.base() * t.height();
        };
    }

    static String classify(Object obj) {
        return switch (obj) {
            case null                         -> "null";
            case Integer i when i < 0         -> "negative int: " + i;
            case Integer i when i == 0        -> "zero";
            case Integer i                    -> "positive int: " + i;
            case String s when s.isBlank()    -> "blank string";
            case String s                     -> "string: " + s;
            case int[] arr                    -> "int array of length " + arr.length;
            default                           -> "other: " + obj.getClass().getSimpleName();
        };
    }

    public static void main(String[] args) {
        System.out.printf("Circle area: %.2f%n", area(new Circle(5)));
        System.out.printf("Rect area: %.2f%n", area(new Rectangle(4, 6)));
        System.out.printf("Tri area: %.2f%n", area(new Triangle(3, 8)));

        System.out.println(classify(null));
        System.out.println(classify(-5));
        System.out.println(classify(0));
        System.out.println(classify(42));
        System.out.println(classify(""));
        System.out.println(classify("hello"));
        System.out.println(classify(new int[]{1, 2, 3}));
    }
}

// Example 5: Record Patterns and Nested Patterns (Java 21)
// File: RecordPatterns.java
public class RecordPatterns {

    record Point(int x, int y) {}
    record Line(Point start, Point end) {}

    sealed interface Expr permits Const, Add, Mul {}
    record Const(int value) implements Expr {}
    record Add(Expr left, Expr right) implements Expr {}
    record Mul(Expr left, Expr right) implements Expr {}

    static int eval(Expr expr) {
        return switch (expr) {
            case Const(int v)             -> v;
            case Add(Expr l, Expr r)      -> eval(l) + eval(r);
            case Mul(Expr l, Expr r)      -> eval(l) * eval(r);
        };
    }

    static String describePoint(Object obj) {
        return switch (obj) {
            case Point(int x, int y) when x == 0 && y == 0 -> "origin";
            case Point(int x, int y) when x == 0 -> "on y-axis at " + y;
            case Point(int x, int y) when y == 0 -> "on x-axis at " + x;
            case Point(int x, int y)              -> "point at (" + x + "," + y + ")";
            default                               -> "not a point";
        };
    }

    static boolean isHorizontal(Line line) {
        return switch (line) {
            case Line(Point(int x1, int y1), Point(int x2, int y2)) -> y1 == y2;
        };
    }

    public static void main(String[] args) {
        System.out.println(describePoint(new Point(0, 0)));    // origin
        System.out.println(describePoint(new Point(0, 5)));    // on y-axis at 5
        System.out.println(describePoint(new Point(3, 4)));    // point at (3,4)

        // (2 + 3) * 4
        Expr expr = new Mul(new Add(new Const(2), new Const(3)), new Const(4));
        System.out.println("Result: " + eval(expr));           // 20

        Line h = new Line(new Point(0, 5), new Point(10, 5));
        System.out.println("Is horizontal: " + isHorizontal(h));  // true
    }
}