Activity 3.3 Designing with Methods: Stepwise Refinement

Introduction

Designing with Methods

Breaking Down Problems Step by Step

What Is Stepwise Refinement?

Stepwise refinement is the process of starting with a broad goal and gradually dividing it into smaller, more manageable tasks.

Each step adds more detail until your program is complete and ready to run.

Why Use Stepwise Refinement?

Organization: Plan before coding. Avoid writing everything in main().
Focus: Build and test one small part at a time.
Reusability: Each method can be reused or replaced later.
Debugging: When something breaks, you know exactly where to look.

Example of Refinement

Suppose we want to build a simple dice game. Instead of writing the whole game at once, we can break it down:

Roll a single die
Roll two dice and calculate the total
Apply the game rules for a round
Repeat rounds until the player quits

Each step becomes a method. Together, they form a complete game.

Our Goal

We'll design a simplified version of the dice game Craps using stepwise refinement.

Each method will handle one small, focused task to make the code easier to test and read.

'F' → Fullscreen

Objectives

Apply stepwise refinement to design a small game.
Use parameters and return values to control program flow.
Refactor working code into clean, reusable methods.

Activity Tasks

Create a new Java file named CrapsGame.
Build and run after each step. Do not skip ahead.

Task 1: Roll a Single Die (print only)

Implement rollDie() that prints the die result.
Call it several times from main().

1
import java.util.Scanner;
2

3
public class Program
4
{
5
    public static void main(String[] args)
6
    {
7
        System.out.println("--- CRAPS ---");
8
        // Call several times to verify randomness
9
        rollDie();
10
        rollDie();
11
        rollDie();
12
    }
13

14
    // Step 1: print the die result (no return yet)
15
    static void rollDie()
16
    {
17
        int die = (int)(Math.random() * 6) + 1;
18
        System.out.println("Rolled: " + die);
19
    }
20
}

Task 2: Return Instead of Print

Modify rollDie() to return the value.
Print in main() after the call.

1
import java.util.Scanner;
2

3
public class Program
4
{
5
    public static void main(String[] args)
6
    {
7
        System.out.println("--- CRAPS ---");
8

9
        int d1 = rollDie();
10
        int d2 = rollDie();
11
        System.out.println("You rolled: " + d1 + " and " + d2);
12
    }
13

14
    // Step 2: now return the value instead of printing
15
    static int rollDie()
16
    {
17
        return (int)(Math.random() * 6) + 1;
18
    }
19
}

Task 3: Roll Two Dice

Create rollDice() that calls rollDie() twice, prints the breakdown, and returns the total.
Create promptRoll() for user input.

1
import java.util.Scanner;
2

3
public class Program
4
{
5
    public static void main(String[] args)
6
    {
7
        System.out.println("--- CRAPS ---");
8
        promptRoll();
9
        int total = rollDice();
10
        System.out.println("Total: " + total); // Test variable for correctness
11
    }
12

13
    static int rollDie()
14
    {
15
        return (int)(Math.random() * 6) + 1;
16
    }
17

18
    // Step 3: compose method to roll two dice
19
    static int rollDice()
20
    {
21
        int die1 = rollDie();
22
        int die2 = rollDie();
23
        int total = die1 + die2;
24
        System.out.println("You rolled " + die1 + " + " + die2 + " = " + total);
25
        return total;
26
    }
27

28
    // Roll dice input
29
    static void promptRoll()
30
    {
31
        Scanner input = new Scanner(System.in);
32
        System.out.print("Press Enter to roll...");
33
        input.nextLine(); // simple pause
34
    }
35
}

Task 4: Come-Out Roll Rules

Write evaluateComeOutRoll(int roll) to print the outcome and return whether the round is over.
If the round continues, set point = roll.

1
import java.util.Scanner;
2

3
public class Program
4
{
5
    public static void main(String[] args)
6
    {
7
        System.out.println("--- CRAPS ---");
8
        int point = 0;
9

10
        promptRoll();
11
        int roll = rollDice();
12
        boolean roundOver = evaluateComeOutRoll(roll);
13

14
        if (!roundOver)
15
        {
16
            point = roll;
17
            System.out.println("The point is now " + point + ".");
18
            // Next task: loop while not over and resolve the point.
19
        }
20
    }
21

22
    static int rollDie()
23
    {
24
        return (int)(Math.random() * 6) + 1;
25
    }
26

27
    static int rollDice()
28
    {
5 collapsed lines
29
        int d1 = rollDie();
30
        int d2 = rollDie();
31
        int total = d1 + d2;
32
        System.out.println("You rolled " + d1 + " + " + d2 + " = " + total);
33
        return total;
34
    }
35

36
    static void promptRoll()
37
    {
3 collapsed lines
38
        Scanner input = new Scanner(System.in);
39
        System.out.print("Press Enter to roll...");
40
        input.nextLine(); // simple pause
41
    }
42

43
    // Step 4: come-out evaluation
44
    static boolean evaluateComeOutRoll(int roll)
45
    {
46
        if (roll == 7 || roll == 11)
47
        {
48
            System.out.println("Rolled a " + roll + "! You win!");
49
            return true;
50
        }
51
        else if (roll == 2 || roll == 3 || roll == 12)
52
        {
53
            System.out.println("Rolled a " + roll + ". You lose.");
54
            return true;
55
        }
56
        else
57
        {
58
            System.out.println("Rolled a " + roll + ".");
59
            return false;
60
        }
61
    }
62
}

Task 5: Resolve the Point

Add evaluatePointRoll(int roll, int point) and loop until win/lose.

1
import java.util.Scanner;
2

3
public class Program
4
{
5
    public static void main(String[] args)
6
    {
7
        System.out.println("--- CRAPS ---");
8

9
        int point = 0;
10
        boolean gameOver;
11

12
        promptRoll();
13
        int roll = rollDice();
14
        gameOver = evaluateComeOutRoll(roll);
15

16
        if (!gameOver)
17
        {
18
            point = roll;
19
            System.out.println("The point is now " + point + ".");
20

21
            // Step 5: keep rolling until win (hit point) or lose (7)
22
            while (!gameOver)
23
            {
24
                promptRoll();
25
                roll = rollDice();
26
                gameOver = evaluatePointRoll(roll, point);
27
            }
28
        }
29

30
        System.out.println("Thanks for playing!");
31
    }
32

33
    static int rollDie()
34
    {
35
        return (int)(Math.random() * 6) + 1;
36
    }
37

38
    static int rollDice()
39
    {
5 collapsed lines
40
        int d1 = rollDie();
41
        int d2 = rollDie();
42
        int total = d1 + d2;
43
        System.out.println("You rolled " + d1 + " + " + d2 + " = " + total);
44
        return total;
45
    }
46

47
    static void promptRoll()
48
    {
3 collapsed lines
49
        Scanner input = new Scanner(System.in);
50
        System.out.print("Press Enter to roll...");
51
        input.nextLine(); // simple pause
52
    }
53

54
    static boolean evaluateComeOutRoll(int roll)
55
    {
15 collapsed lines
56
        if (roll == 7 || roll == 11)
57
        {
58
            System.out.println("Rolled a " + roll + "! You win!");
59
            return true;
60
        }
61
        else if (roll == 2 || roll == 3 || roll == 12)
62
        {
63
            System.out.println("Rolled a " + roll + ". You lose.");
64
            return true;
65
        }
66
        else
67
        {
68
            System.out.println("Rolled a " + roll + ".");
69
            return false;
70
        }
71
    }
72

73
    // Step 5: resolve after point is set
74
    static boolean evaluatePointRoll(int roll, int point)
75
    {
76
        if (roll == point)
77
        {
78
            System.out.println("Rolled a " + roll + "! You win!");
79
            return true;
80
        }
81
        else if (roll == 7)
82
        {
83
            System.out.println("Rolled a 7. You lose.");
84
            return true;
85
        }
86
        else
87
        {
88
            System.out.println("Rolled a " + roll + ". Still shooting for " + point + ".");
89
            return false;
90
        }
91
    }
92
}

Sample Output

--- CRAPS ---
Press Enter to roll...
You rolled 4 + 3 = 7
Rolled a 7! You win!
Thanks for playing!

Reflection Questions

Which method did you write first, and why was that a good starting point?
How did return values help you control the game flow?
After refactoring, what does main() focus on now?

Submission

Submit your completed .java file and reflection answers to the appropriate dropbox.