Demo: predict-then-run expression challenge

Examples

Example 1: the first four predictions (simple)

Create Predict.java with the first four expressions below. Before you run, copy the table above and write your prediction for each into the Prediction column.

public class Predict {
    public static void main(String[] args) {
        System.out.println("1: " + 17 / 5);
        System.out.println("2: " + 17 % 5);
        System.out.println("3: " + 17 / 5.0);
        System.out.println("4: " + (2 + 3 * 4 % 5));
        // more lines come in the next examples
    }
}

Here is the reasoning you should have done:

1. 17 / 5: two ints, so integer division: 3. (Not 3.4.)
2. 17 % 5: 3 * 5 = 15, remainder 2.
3. 17 / 5.0: a double operand, so decimals: 3.4.
4. 2 + 3 * 4 % 5: * and % have equal precedence and group from the left. 3 * 4 is 12, 12 % 5 is 2, 2 + 2 is 4.

(The "1: " + ... part is just a label. Lines 1 to 3 do not need parentheses because the division happens before the +; line 4 needs them so that the + inside is arithmetic and not text.)

Example 2: increments, text, and short-circuiting (practical)

Now add the next expressions in the same method and predict each one before running.

        int i = 4;
        int a = i++ + i;
        System.out.println("5: a=" + a + " i=" + i);
        System.out.println("6: " + (1 + 2 + "3"));
        System.out.println("7: " + ("x=" + 1 + 2));
        int d = 0;
        System.out.println("8: " + (d != 0 && 10 / d > 1));
        System.out.println("9: " + (false && true || true));
        System.out.println("10: " + (10 / 4 * 4.0));

Reasoning for each:

1. i++ + i: operands are read left to right. i++ gives 4 and i becomes 5; then the second i is 5. So a is 9 and i is 5.
2. 1 + 2 + "3": this is the one expected to catch you. Many people predict 6. Following the rule above, it is "33".
3. "x=" + 1 + 2: "x=12".
4. The guard from Lesson 5: d != 0 is false, so the division is skipped. The result is false, with no crash.
5. && groups before ||: (false && true) || true is false || true, which is true.
6. 10 / 4 * 4.0: left to right, 10 / 4 is integer division (2), then 2 * 4.0 is 8.0. The double appears too late to save the fraction.

Run the program with javac Predict.java followed by java Predict. The output, in JDK 21, is:

1: 3
2: 2
3: 3.4
4: 4
5: a=9 i=5
6: 33
7: x=12
8: false
9: true
10: 8.0

If your table has a mismatch, do not just correct the prediction. Write the reason, as in the next example.

Example 3: the mistake log (realistic)

Imagine a developer who predicted line 6 as 6 and line 10 as 10.0. Their completed table might look like this:

Each "Why" is one sentence naming a rule, not "I was wrong". The sentences matter more than the numbers: they are a list of the rules you tend to forget. A second program shows more text and char cases:

public class Predict2 {
    public static void main(String[] args) {
        int x = 9;
        x -= 2 * 3;
        System.out.println(x);
        System.out.println("n=" + 1 + 2);
        System.out.println("n=" + (1 + 2));
        System.out.println(1 + 2 + "n");
        System.out.println('a' + 1);
        System.out.println("" + 'a' + 1);
    }
}

3
n=12
n=3
3n
98
a1

First line: x -= 2 * 3 is x = x - (2 * 3), so 9 - 6 is 3. The "n=" + (1 + 2) line shows parentheses repairing the text mix-up that "n=" + 1 + 2 causes. This is a real bug source: a message such as "Total: " + price + tax prints two numbers side by side instead of adding them.