“Consecutive Heads” program

Question

So... I have a program in which I want to flip heads three times in the row.

What I'm asking for is for proposals of other solutions for this program, in pro way, as You do in natural sense.

That's my code as Java novice.

/*
 * File: ConsecutiveHeads.java
 * ----------------
 * This program flips a coin repeatly until three consecutive heads
 * are tossed.
 */

import acm.program.*;
import acm.util.*;

public class ConsecutiveHeads extends ConsoleProgram {
    /* Run the program */
    public void run() {
        println("This program flips a coin until there are three" +
                "heads in the row.");
        while(counter != 3) {
            FlipACoin();
        }
        println("Yupii! There are already three same heads in the row :)");
    }

    /* Flip a coin. Then if heads are tossed, increment our counter.
     * In tails case, zero counter. */
    private void FlipACoin() {
        boolean rank = rgen.nextBoolean();
        if(rank) {
            println("heads");
            counter++;
        } else {
            println("tails");
            counter = 0;
        }
    }

    /* Create an instance variable for the random number generator */
    private RandomGenerator rgen = new RandomGenerator();

    /* Create an instance variable for counter detecting three heads in row */
    private int counter = 0;
}

Answer 1

Your function is called FlipACoin() but you are doing more than just flipping the coin.
A more appropriate name might be FlipACoinAndCountConsecutiveHeadRolls().

I'd suggest keeping the function as simple as the name suggests and return a string (or bool) from FlipACoin(), then examine the result outside the function.
This will also allow you to make the counter a local variable to the run function, which will make the class smaller.

Answer 2

Some things you could consider

• make the starting class a simple program which calls other methods and/or classes to do most of the work.
• if you want something more general, you could use an abstract output stream so it can be captured or even use a Listener interface.
• make fields which are not intended to change final this can improve clarity.
• is it conventional to place fields then constructors then methods as the class order.
• you could restructure the fields/method calls to be thread safe if that might be an issue. e.g. SimpleDateFormat is not thread-safe and causes no end of concern.

Answer 3

I'd do it like this:

/*
 * File: ConsecutiveHeads.java
 * ----------------
 * This program flips a coin repeatly until three consecutive heads
 * are tossed.
 */

import acm.program.*;
import acm.util.*;

public class ConsecutiveHeads extends ConsoleProgram {
    /* Run the program */
    public void run() {
        println("This program flips a coin until there are three" +
                "heads in the row.");
        while(!TryFlipThreeHeads()) {
        }
        println("Yupii! There are already three same heads in the row :)");
    }

    /* Flip a coin. */
    private boolean FlipACoin() {
        boolean rank = rgen.nextBoolean();
        if(rank) {
            println("heads");
        } else {
            println("tails");
        }
        return rank;
    }

    private boolean TryGetThreeHeads() {
         for(int counter = 0; counter < 3; counter++)
         {
              // if we get a tail, give up
              if(!FlipACoin()) return false;
         }
         return true;
    }

    /* Create an instance variable for the random number generator */
    private RandomGenerator rgen = new RandomGenerator();
}

That way each piece is self-contained. FlipACoin just flips the coin, it doesn't keep track of counting. And TryGetThreeHeads() only worries about trying to flip three heads not the process of flipping each coin.