A program can only choose and repeat

Every program you've written so far is a shopping list. Java starts at the top, does each line once, hits the bottom, and quits. Useful, but a bit sad. A shopping list can't notice that the shop's shut.

To fix that, Java hands you exactly two new powers. Only two. One lets a program choose between paths. The other lets it repeat work.

That's the lot. Every game, every website, every app on your phone is those two moves stacked up thousands of times. Nothing else gets added later.

What you'll be able to do

• Ask Java a true-or-false question, and act on the answer.
• Repeat work until something changes — and stop a program stuck repeating forever.
• Read what a person types, so your program becomes a conversation.
• Write a guessing game, then flip it so the computer guesses.

Section 1It all starts with a yes-or-no question

Java's got a type for exactly that. You've already met it in 0.2: boolean, a box holding only true or false. No maybe.

You rarely type those by hand. Instead you let Java work one out by comparing two values. Java hands you the same six you met in maths class:

a == b   a != b   a < b   a > b   a <= b   a >= b

An operator is a symbol that does a job — + is one too. Here's the bit maths class never mentioned: every one of these six hands back a boolean, not a number.

Two are spelled oddly. != means "not equal", because ! means "not" in Java. And <= is one operator spelled with two characters, so never put a space in the middle.

int age = 15;

System.out.println(age > 12);
System.out.println(age > 90);
System.out.println(age == 15);
System.out.println(age != 15);
System.out.println(age <= 15);

boolean canRide = age >= 12;
System.out.println("canRide = " + canRide);

Line 1 puts 15 in an int box — old news from 0.2. The five println lines each print one comparison. The last pair is the move worth learning: boolean canRide = age >= 12; stores the answer instead of printing it.

$ javac Compare.java
$ java Compare
true
false
true
false
true
canRide = true

Five booleans in code order, then the stored one. Only the fourth is false: 15 is not different from 15.

The one that gets everyone: = versus ==

It's the most common mistake in beginner Java. Not one of them. The most.

• = is an assignment. It puts a value in a box. A command: "make score be 10."
• == is a comparison. It asks whether two things match: "is score 10?"

Java catches this half the time. src/OneEquals.java has the bug on purpose:

int score = 3;
if (score = 10) {
    System.out.println("Perfect score!");
}

$ javac OneEquals.java
OneEquals.java:6: error: incompatible types: int cannot be converted to boolean
        if (score = 10) {
                  ^
1 error

That error is the exact truth. score = 10 is a command, and its result is the number 10 — an int. But if demands a boolean. Java can't turn 10 into true or false, so it refuses. The ^ points at the guilty character.

That's the good case. Now the bad one.

boolean gameOver = false;

if (gameOver = true) {
    System.out.println("Game over, man.");
}

System.out.println("gameOver is now " + gameOver);

$ java OneEqualsBool
Game over, man.
gameOver is now true

Section 2Choosing: if, else if, else

A boolean nobody acted on is an unused answer. Here's how you act on one: if.

if (/* a true-or-false question */) {
    // runs only when the answer is true
}

Three parts. The word if. Round brackets holding a question that must give a boolean. Curly brackets holding the work. True means run the block. False means skip it. A block is the name for a group of lines inside curly brackets — main is one.

You can chain forks together. src/Grade.java:

int mark = 74;

if (mark >= 90) {
    System.out.println("A");
} else if (mark >= 75) {
    System.out.println("B");
} else if (mark >= 50) {
    System.out.println("C");
} else {
    System.out.println("Not yet");
}

Line 1 stores 74. Java then works down the chain, and here's the bit people miss: it stops at the first true one. At least 90? No. At least 75? No — 74 is one short. At least 50? Yes. Print "C", then jump past all the rest, else included.

else has no brackets because it's the catch-all. It runs when everything above came out false, and you don't have to include one.

$ java Grade
C

So order decides everything, and a chain in the wrong order is a real bug. Put mark >= 50 first and every passing mark becomes a C, including 95. It compiles, runs, and lies to you.

Always write the curly brackets

Java lets you leave them off when the body is one line. Lots of tutorials do. Don't.

int temperature = 15;

if (temperature > 30)
    System.out.println("It is hot.");
    System.out.println("Drink water.");

System.out.println("Done.");

$ java NoBraces
Drink water.
Done.

Section 3Asking two things at once

Real questions rarely come one at a time. "Are you over 12 and with an adult?" Java's got three tools for stitching them together.

• && — and. True only when both sides are true.
• || — or. True when at least one side is true.
• ! — not. Flips a boolean to its opposite.

|| is two vertical bars, usually sharing a key with the backslash. Note the doubles — single & and | exist and behave differently.

The word that trips people is "or". In English, "tea or coffee?" means pick one. Java's || is happy if both are true. It asks "at least one?", not "exactly one?".

Don't memorise this. Drive it. Below are two switches, a and b. Flip both and watch which rows change, and which stubbornly don't. Your mission: find the one setting where a && b comes out true. There is exactly one.

Found it? Both switches on. That's "and" being fussy — one true out of four. Now try the same hunt for a || b being false: also one setting, both off. "Or" is the easy-going one. src/TruthTable.java prints all four rows if you'd rather hear it from Java.

int age = 15;
boolean withAdult = true;

if (age >= 18 || (age >= 12 && withAdult)) {
    System.out.println("You may watch the film.");
} else {
    System.out.println("Sorry, not tonight.");
}

Read that condition from the inside out. The inner brackets ask "at least 12 and with an adult?" — true && true, so true. The outer question is "18 or older, or that inner thing?" Left half false. Right half true. And "or" needs only one. Film happens. Those inner brackets group the "and" so it's answered first, exactly like brackets in maths.

$ java AndOrNot
AND: false
OR:  true
NOT: false
You may watch the film.

The first three lines come from earlier in that file, where hasTicket is true and hasSnack is false. Ticket and snack? Only one, so false. Ticket or snack? One is enough, so true. Not ticket? The ticket's real, so flipping it gives false.

Java is lazy, and that turns out to be a gift

Given A && B, Java checks A first. A false A makes the whole thing false — look at the table. So Java doesn't read B at all. Same with A || B: a true A settles it, and B never runs.

That's short-circuit evaluation — stopping once the answer is known. It's more than a speed trick. It lets the first half of a condition guard the second half.

int sweets = 7;
int people = 0;

if (people != 0 && sweets / people > 2) {
    System.out.println("Everyone gets at least three.");
} else {
    System.out.println("Cannot share those out.");
}

$ java ShortCircuit
Cannot share those out.
Reached this without crashing.
Exception in thread "main" java.lang.ArithmeticException: / by zero
	at ShortCircuit.main(ShortCircuit.java:21)

Section 4Repeating: while, and the loop that never ends

Power number two. A loop is a block Java runs over and over instead of once.

while (/* a true-or-false question */) {
    // runs again and again, while the answer stays true
}

That's one word different from an if, and completely different behaviour. An if checks once. A while checks, runs the block, then comes back and checks again. It stops only when the check comes out false.

int n = 5;

while (n > 0) {
    System.out.println(n);
    n = n - 1;
}

System.out.println("Lift off. n is " + n);

Line 1 sets n to 5. Line 3 asks "is n bigger than 0?" Line 4 prints n. Line 5 makes n one smaller — that line's the whole ballgame, as you'll see. The closing bracket sends Java back to line 3 to ask again. The last line runs once the loop finishes.

Step through it before you look at the output.

$ java Countdown
5
4
3
2
1
Lift off. n is 0

Six checks, five printed lines. That gap's where a lot of loop bugs live.

Now let's break it on purpose

Take Countdown.java and delete one line — the n = n - 1;. That's src/Forever.java:

int n = 5;

while (n > 0) {
    System.out.println(n);
}

System.out.println("You will never see this line.");

Nothing changes n now. So n > 0 is true, stays true, and it'll still be true after the heat death of the universe. That's an infinite loop: a loop with no way out.

Before you run it, learn the escape hatch. Hold Ctrl and press C. In the terminal that means "stop what you're running". Not Command-C, even on a Mac. Keep that finger ready.

Section 5for loops, and the fence-post problem

Most loops follow the same tired pattern. Set a counter, check it, change it. Forget the third job and you've got the infinite loop from a moment ago. So Java has shorthand — src/Counting.java writes one loop twice:

int i = 0;
while (i < 5) {
    System.out.println("i is " + i);
    i = i + 1;
}

for (int j = 0; j < 5; j++) {
    System.out.println("j is " + j);
}

Those two do exactly the same thing. The for gathers the three counter jobs onto one line, split by semicolons:

1. int j = 0 — the setup. Runs once, before anything else.
2. j < 5 — the check. Runs before every turn, exactly like a while condition.
3. j++ — the change. Runs after every turn, then Java goes back to the check.

j++ is new: shorthand for j = j + 1. There's j-- for subtracting one.

So the order runs setup, check, body, change, check, body, change… and out. The change happens at the end of a turn. So the counter you see inside the body is always the value that passed the check.

$ java Counting
-- while --
i is 0
i is 1
i is 2
i is 3
i is 4
-- for --
j is 0
j is 1
j is 2
j is 3
j is 4

Identical, as promised. Use while when you don't know how many turns you need — "until the player guesses right". Use for when you do — "five times".

Why 0, and why < instead of <=

That loop printed 0, 1, 2, 3, 4. Five numbers, and 5 isn't one of them. New programmers find this maddening, so let's make it plain.

Starting at 0 and stopping before the limit is a gift. i < 5 runs exactly 5 times, and you read the count straight off the code. With i = 1; i <= 5 you get 5 turns too, but now you're doing arithmetic in your head. And in chapter 0.5, lists of data turn out to be numbered from 0 as well.

An off-by-one error is a loop running one turn too many or too few. It's usually one character. src/OffByOne.java lines up three cases:

$ java OffByOne
less than 5:      0 1 2 3 4
less or equal 5:  0 1 2 3 4 5
counting down:    5 4 3 2 1

One extra = gives you six numbers instead of five. The third line is a for going backwards: setup at 5, check i > 0, change i--. The three parts needn't count upward — they only have to agree.

Leaving early: break and continue

• break — leave the loop now. Skip the rest of the block and all remaining turns.
• continue — skip the rest of this turn only. Go straight to the next check.

for (int i = 0; i < 10; i++) {
    if (i == 4) {
        break;
    }
    System.out.print(i + " ");
}

for (int i = 0; i < 10; i++) {
    if (i % 2 == 1) {
        continue;
    }
    System.out.print(i + " ");
}

The first loop is set up for ten turns. But when i hits 4 the break fires and abandons the lot. The second uses % from 0.2 — the remainder after dividing. So i % 2 == 1 means "i is odd". For each odd number, continue jumps past the print.

$ java BreakContinue
break at 4:    0 1 2 3
skip odds:     0 2 4 6 8

The first prints 0 to 3 — it stopped before printing 4, because the check comes first. Use both sparingly: a loop with breaks scattered through it gets hard to follow.

One more chooser: switch

Checking one variable against a list of exact values makes a long else if chain repetitive. And that's what switch is built for.

int choice = 2;

switch (choice) {
    case 1:
        System.out.println("New game");
        break;
    case 2:
        System.out.println("Load game");
        break;
    case 3:
        System.out.println("Quit");
        break;
    default:
        System.out.println("No such option");
}

Java looks at choice, finds the matching case label, and jumps there. choice is 2, so it lands on case 2: and prints "Load game". break then leaves the switch. default is the catch-all, like else.

Those break statements look like clutter. Watch what happens without them.

$ java Menu
Load game
--- now with the breaks removed ---
Load game
Quit
No such option

Section 6Letting a person type

Everything so far was decided before the program started. To read what somebody types you need a Scanner. It's a piece of Java that watches the keyboard and hands you what arrives.

import java.util.Scanner;

public class AskAge {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        System.out.print("How old are you? ");
        int age = in.nextInt();

        if (age >= 18) {
            System.out.println("You can vote.");
        } else {
            System.out.println("Not yet. " + (18 - age) + " years to go.");
        }
    }
}

Four new things, one at a time.

import java.util.Scanner; sits at the very top, above the class. Java ships with thousands of ready-made tools and doesn't load them all. import says "I'll be using the one called Scanner, go and find it". Forget it and the compiler says it cannot find the symbol Scanner.

Scanner in = new Scanner(System.in); builds one and names it in. System.in is the keyboard, the way System.out is the screen. new means "build me a fresh one" — more on that in Phase 1.

System.out.print, not println. The ln means "line" and jumps to a new one after printing. Here we're keeping the cursor right after the question mark, so the typing lands on the same line.

in.nextInt() reads one whole number and hands it back. It also waits — the program stops dead there until somebody types a number and presses Enter.

$ java AskAge
How old are you? 15
Not yet. 3 years to go.

15 isn't 18 or more, so the else ran and 18 - age worked out the 3. There's also in.nextLine() for a whole line of text, and in.next() for a single word.

That's the whole of Scanner. Now, before you write a single line with it, one trap. Mix nextInt() and nextLine() in the wrong order and your program skips a question. Learn it here, not at midnight.

The trap that has wasted more beginner evenings than any other

System.out.print("Your age? ");
int age = in.nextInt();

System.out.print("Your name? ");
String name = in.nextLine();

System.out.println("Hello [" + name + "], age " + age + ".");

$ printf '15\nSam\n' | java ScannerTrap
Your age? Your name? Hello [], age 15.

int age = in.nextInt();
in.nextLine();                 // throw away the rest of that line

$ printf '15\nSam\n' | java ScannerFixed
Your age? Your name? Hello [Sam], age 15.

Section 7The project: a game, then the twist

You've now got all three ingredients: a loop to keep going, an if to judge, a Scanner to listen. That's a game.

int secret = 42;
int guess = 0;
int tries = 0;

while (guess != secret) {
    System.out.print("Your guess: ");
    guess = in.nextInt();
    tries = tries + 1;

    if (guess < secret) {
        System.out.println("Too low.");
    } else if (guess > secret) {
        System.out.println("Too high.");
    } else {
        System.out.println("Got it in " + tries + " guesses!");
    }
}

Three boxes. secret is the answer, fixed at 42 so the game behaves the same every test. guess starts at 0 because it must hold something before the first check, and 0 safely isn't the secret. tries counts attempts.

The condition guess != secret means "keep going while the guess is wrong". It's a while and not a for because nobody knows how many turns it'll take.

Inside: print the prompt, read a number, add one to the count, then the if chain gives the hint. When the guess matches, the celebration prints. Java loops back, finds guess != secret is now false, and stops on its own. No break needed.

$ printf '50\n25\n37\n43\n41\n42\n' | java GuessGameEcho
I picked a number from 1 to 100.
Your guess: 50
Too high.
Your guess: 25
Too low.
Your guess: 37
Too low.
Your guess: 43
Too high.
Your guess: 41
Too low.
Your guess: 42
Got it in 6 guesses!

Six guesses out of a hundred numbers, and that's not luck. Look what they did: 50 split the range in half, 25 split what was left, then 37. Each answer threw away a chunk.

Now flip it

What if the computer guesses and you answer? It's got no idea what you picked. It only gets "too high" or "too low". Sounds hopeless.

The whole trick is to always guess the middle. Every answer then wipes out half the numbers still possible — and one yes-or-no answer can't do better than half. Watch it hunt for 73.

$ java HalvingTrace
try 1: range 1-100 (100 left), guess 50
try 2: range 51-100 (50 left), guess 75
try 3: range 51-74 (24 left), guess 62
try 4: range 63-74 (12 left), guess 68
try 5: range 69-74 (6 left), guess 71
try 6: range 72-74 (3 left), guess 73
correct after 6 guesses

int low = 1;
int high = 100;
int tries = 0;

while (low <= high) {
    int guess = (low + high) / 2;
    tries = tries + 1;

    System.out.print("Guess " + tries + ": is it " + guess + "? (h/l/y) ");
    String reply = in.next();

    if (reply.equals("y")) {
        System.out.println("Found it in " + tries + " guesses.");
        break;
    } else if (reply.equals("h")) {
        high = guess - 1;
    } else if (reply.equals("l")) {
        low = guess + 1;
    }
}

low and high are the edges of the range still in play. The condition low <= high means "there's at least one number left". If low ever passes high, the range is empty and you must have lied.

(low + high) / 2 is the midpoint. Whole-number division from 0.2 chops the fraction off, and that's fine. in.next() reads one word. Then three .equals() tests, because this is text and == would betray us — Section 1's warning, earning its keep.

The two update lines are the heart of it. Too high? The answer's below the guess, so high = guess - 1. That - 1 matters: the guess itself is ruled out. Too low? low = guess + 1. Get either wrong and the range stops shrinking — hello, infinite loop. break leaves at once on a correct guess.

$ java HalvingProof
Numbers tested: 100
Worst case: 7 guesses (secret was 2)

$ printf 'h\nh\nh\nh\nh\nl\ny\n' | java ComputerGuessesEcho
Think of a number from 1 to 100. Do not tell me.
Guess 1: is it 50? (h/l/y) h
Guess 2: is it 25? (h/l/y) h
Guess 3: is it 12? (h/l/y) h
Guess 4: is it 6? (h/l/y) h
Guess 5: is it 3? (h/l/y) h
Guess 6: is it 1? (h/l/y) l
Guess 7: is it 2? (h/l/y) y
Found it in 7 guesses.

$ java Ranges
1 to 100 -> worst case 7 guesses
1 to 1000 -> worst case 10 guesses
1 to 1000000 -> worst case 20 guesses

Section 8Your turn

Section 9Check yourself

Section 10What broke, what surprised you

Six things here were built to catch you out. Note which ones did — writing it down turns a surprise into a memory.

• if (gameOver = true) compiled, ran, and silently rewrote your variable.
• "Drink water." printed on a 15-degree day, because indentation is decoration.
• A division by zero sat inside a condition and never happened.
• Deleting one line turned a five-line countdown into a million lines of 5.
• A switch with no break ran three cases instead of one.
• nextLine() after nextInt() came back empty and never waited for you.

If any of those still feels wrong, chase it. Change the file, run it, watch. Being surprised and then checking — that's the whole method. Faster than reading, and it sticks.

One last thing. Every program here crammed its logic into main. That works at ten lines. It's unreadable at a hundred. Next you'll learn how to take a chunk of work, give it a name, and use it anywhere.