Conditionals

Fallthrough, and why it exists

Without break, switch does not stop at the end of a case. It carries on.

switch (day) {
    case 1:
        result = "monday";       // no break
    case 2:
        result += " tuesday";
        break;
}
// day = 1 gives you "monday tuesday"

This behaviour is called fallthrough. It is almost always a bug when it happens by accident, and Java gives you no warning at all.

So why keep it? Because of the stacked-label shape:

case 6:
case 7:
    type = "weekend";
    break;

case 6: has an empty body, so it falls straight into case 7:. That useful pattern and the dangerous bug are the same mechanism.

Arrow labels and switch expressions

Java 14 made arrow labels and switch expressions permanent language features.

String type = switch (day) {
    case 6, 7 -> "weekend";
    case 1    -> "monday";
    default   -> "midweek";
};

Label syntax and construct type are separate choices. A switch statement performs work. A switch expression produces a value and must cover every possible selector value. Arrow labels work in either construct. The example above is an expression because its result is assigned to type.

What classic switch accepts

These are language rules. They do not promise one bytecode or machine-code strategy. A compiler can use a dense table for dense integer cases or a lookup for sparse cases. String switching must still distinguish different strings that have the same hash code.

Use switch because it states a fixed choice over one selector. Use if for ranges, unrelated conditions, or conditions that depend on several values.

Passing null to a classic String, wrapper, or enum switch throws NullPointerException. Check for null first when it is a valid input state.

Floating-point equality

System.out.println(0.1 + 0.2 == 0.3);    // false

You already know why, from Section 2.2. Those three numbers have no exact form in binary, so the closest-to-0.1 plus the closest-to-0.2 is not bit for bit the closest-to-0.3.

If the domain means “close enough,” define a tolerance that matches its units and scale:

double tolerance = 0.000001;
if (Math.abs(a - b) <= tolerance) { }   // domain-specific absolute tolerance

One fixed epsilon is not correct for every magnitude. Some programs use a relative tolerance, some require exact bit-level equality, and money often needs decimal arithmetic such as BigDecimal. Choose the comparison contract before choosing the code.

Text identity and text content

Literal pooling can make an identity comparison appear to compare text:

String a = "hi";
String b = "hi";
String c = new String("hi");

System.out.println(a == b);         // true
System.out.println(a == c);         // false
System.out.println(a.equals(c));    // true

Same three letters in all three variables. == says yes for one pair and no for the other.

The reason is that == on objects does not compare contents. It compares whether the two variables point at the same object.

Java interns matching String literals, so these two literal expressions designate one pooled object. That is why a == b is true. new String("hi") creates a distinct object, and runtime input commonly produces another distinct object. Compile-time concatenation can also be interned, so the construction syntax is not a reliable content test.

Scanner scanner = new Scanner(System.in);
String typed = scanner.nextLine();       // user types: admin

if (typed == "admin")        { }   // asks whether both references designate one object
if ("admin".equals(typed))   { }   // compares text and is safe when typed is null

Two later sections finish this story. Section 8.3 explains what equals() actually is and why you often have to write your own. Phase IX explains the String pool and why it exists.

The ternary, used well

String label = (count == 1) ? "item" : "items";

Use it to choose between two short value expressions. If either branch performs several actions, or nesting makes the types and grouping hard to read, use an if statement.