CPSC 170 Lab 5
Events, Interfaces and Polymorphism

As usual, create a lab5 subdirectory for today's lab, open this document in FireFox, and start emacs.

Thinking about Events

Throughout this class, we have been working with event-based programming. The general idea is that things can happen during the execution of the program that we wish to respond to. To capture these events , we establish listeners . A listener is simply a block of code that is executed when a certain event occurs. For example, to respond to a button being pushed, we define an ActionListener. Since we want to respond to different events in different ways, we would like to extend the capabilities of the ActionListener to suit our needs.

However! ActionListeners only do one thing - respond to an "actionPerformed". Moreover, since we are always going to specify what to do in case there was an "actionPerformed", the actionListener is actually abstract!

So, we have an abstract class, where all methods are abstract - this is a good candidate for an interface! Therefore, when we define a class to respond to events, we don't extend ActionListener, we ___________________________________ ActionListener.

Timers

We typically think of events as being something that the user has done, i.e. clicking on a button, but that is not always the case. We might also be interested in generating events at regular intervals. For example, we might want a program that checks for new e-mail every 15 minutes. To acheive this, we use a Timer object to generate events for us. A timer object has an interval, measured in milliseconds, and a listener that defines the code to be executed after the interval of time has elapsed. (see page 470-474 or JavaDoc for more details)

Download the file drawBars.tgz . Uncompress it using the command

tar xzf drawBars.tgz

This should containt three files: bars.java, BarsPanel.java and drawBars.java Compile drawBars.java and run the file. Observe what it does (be patient, there is a timer in there!)

You should have noticed that the bars changed color, one by one -- if you didn't know better, you would expect that there was a for loop or a while loop controlling the color change. Examine the code to find out what is really going on. Before you move on, you should make sure that you understand:

How much time lapses between color changes?
How does the timer know which bar to alter?
How do we know that all the bars have changed color?
What does the timer do after all the bars have changed color?

Sorting

Often when we sort, especially small lists, the computer is done before we know it (and that's a good thing). However, since we are just getting started with sorting, it is useful to break down the sorting process to allow us to get a better sense of what is happening.

We are going to sort the bars (according to height), using a selection sort (refer to the code on p 500). Instead of doing the entire sort at once, we are going to use the timer to delay processing and see incremental steps. To achieve this you should:

Modify bars.java to make it implement Comparable. Remember from class that a Comparable interface uses one method - compareTo. The semantics of this method are defined on page 320.
In BarsPanel.java, create a method: private int minIndex(int start) -- takes an index start and returns the index of the smallest bar in the list starting at index start.
In BarsPanel.java,Create a method: private void swap(int i, int j) -- takes two indices and swaps the values in the list at those indices.
Modify the refreshListener to implement a selection sort.-- At the conclusion of each timer event, you should see that one more bar is correctly positioned. To make things easier to follow, you should also change the color of the corectly positioned bars to blue. Note - your final code won't be too much different than it does now, right?

Print your work to turn in.

Polymorphism

Consider the game of Monopoly. The game consists of a sequential set of 40 squares containing 28 properties, 6 Action squares (3 "Chance", 3 "Community Chest"), 2 Tax squares, "GO", "Jail", "Free Parking", and "Go To Jail.". The game is played by moving through the set of squares. Every time a player lands of a square, they take a different action, depending on the type of a square. For example, if you land on a "Tax Square", you must pay the bank a certain amount of money, but if you land on an "Action Square" you must draw a card from the appropriate pile and follow the instructions on the card.

Note that this is a perfect example of polymorphism. Take a deep breath and relax, you are not implementing Monopoly during this lab. However you are going to use polymorphism to describe the gameplay. To accomplish this you should:

Create an abstract class called MonopolySquare. This should have an instance variable to keep track of the name of the square (String), a constructor that sets the name, an accessor for the name and an abstract method
```
public abstract String landOn();
```
Create derived classes:
- Property
- Action
- Tax
For each of these classes, you will need to implement the "landOn" method. Each of the derived classes should return a string that describes what the player can do if they land on that square.
Create a simple driver program (MonopolyBoard.java) that does the following:
- Creates an array of (at least) 12 MonopolySquares. You can decide the names and types, but make sure you use at least one of each type.
- Rolls the dice (i.e. randomly selects one from the array)
- Prints out a message indicating which square the player has landed on and what actions they can take.
- Asks the player if they want to keep playing (roll again if they do).