Laboratory 2 Instructions

Laboratory 2: Using Objects

Java API

In this lab, you will practice creating/instantiating objects and passing messages to them. Two short,

unrelated exercises will review basic programming concepts and provide substantial practice in using

objects. You will also become familiar with using the javadoc external documentation format, which

will be a very valuable skill this semester.

Note: Please make sure to include both names at the top of your code, as well as in the comments

section when submitting the lab so both people get credit!

• SingleDie.class //you won't directly use this class, representing a six-sided die

• CrapsDice.class //has the following public interface:

o public CrapsDice() //constructor (creates and uses 2 SingleDie objects, this is called

composition or has-a)

o public int roll() //rolls two SingleDies (six-sided dies) and returns the result

Roll the dice 752 times and report the percentage of times that a 2, 3, or 12 is rolled (one number). You

will need to cast to a double to get the correct percentage (or you will be performing integer division).

Call your driver class Craps.java and, in addition to your main method, include the following static

method:

• public static int playCraps(int num_rolls) //returns the number of times that a 2, 3, or 12 is rolled

To run:

java Craps

Part II: Maze Recursion

First, we’ll show you a demo of what you are trying to accomplish.

Starting Files:

• Drawable.java

• DrawPanel.java

• CenterFrame.java

• MazeGUI.java

• SimpleDialogs.java

• MazeDriver.java

• Maze.java //all of your work is in this file

Lab:

methods are called, the values of the local variables for each method call, and where the method call

occurred in the calling method. When a direction that has not been tried is explored, mark that location as

tried by placing the appropriate integer (from the 5 possible final integers) in the current location within

the 2D array (blue in the figure). Marking a direction as tried will prevent the algorithm from exploring

that location again later. If there is no solution, every location will eventually be marked as tried, and then

the user is informed that there is no solution.

A recursive call in a direction already tried or a direction that is a wall can simply terminate without

doing anything (removing themselves from the call stack as there is no solution in that direction). When a

particular location has had all four directions leading from that location explored (either walls or

directions that have been tried), the algorithm must back track or move to previous locations that have

The maze with tried locations in blue and back tracking in red.

If there is a solution to the maze, eventually the recursive calls will find the solution. The important idea

is that once the solution is found, the methods that are still on the method call stack are those methods

that led to the solution. All other method calls corresponding to directions that have been tried and led to

a dead end have completed and were removed from the call stack. Thus, marking the solution path is

trivial. As the methods that led to the solution complete and come off the stack, mark those locations as

part of the solution (green in the figure).

The maze with solution in green.

Note that you will need to make use of a return value in your recursive calls to the traverse method.

Although it is just a boolean, it is an essential component to getting your maze to work. Don't simply

make recursive calls, store what the recursive calls return to you in a variable to help in decision making.

In particular, you need to determine whether the current location led to a solution. If so, mark as path and

terminate, returning true. Otherwise, try other directions. If all directions have been tried, mark as back

track and return false.

Also note that the grid variable is a 2D array representing your maze. To access the number of rows

within grid, you will need to access grid.length, and to access the number of columns within your grid,

Complete Maze.java. Your red region may look different than mine (why?) but your green region should

look the same.

To compile: javac *.java

To run: java MazeDriver

Or you can run the provided batch file: make.bat

Once finished, one partner should submit the lab on ilearn and include both names in the

comments section, as well as at the top of the actual source code. This lab will be due in 10 days, by

11:59:59 PM.