CS 1331 Homework 9
Due: Monday, November 10, 2008
New due date: Wednesday, November 12, 2008
Introduction

This assignment will give you some experience working with classes, subclasses, interfaces, polymorphism and dynamic binding. You will develop some classes that will be interrelated via has-a and is-a relationships. The program will have you develop a simple simulation in which the classes you create are used by a third party driver (main) program. This assignment is relatively open-ended so you should be creative and have some fun with it.

Remember that you are free to collaborate with other students on the homework as long as you acknowledge the collaboration in your collaboration statement. Because this program requires several related classes, it lends itself more to teamwork development, although you are still responsible for understanding the concepts involved in every part of the program.
Here Fishy, Fishy

In this program you will develop a simple aquarium simulation. The aquarium will be modeled by a class itself, and then each of the objects inside it will have their own class too. We will set up specific methods for each class that you must implement.

To begin, an aquarium is a rectangle with water inside. (We suggest a color like (109, 171, 177) for a nice sea blue.) An aquarium should simply be a subclass of a JFrame. Aquariums hold a number of background-style objects such as sand, plants, and aerators. We will create an interface that models background objects and each such object must implement this interface. An aquarium then will also have an addObject() method that affiliates one of these objects with the aquarium. Finally, the aquarium will have a refresh() method that redraws the aquarium in the following order: First redraw the background, then draw each object in the order they were added. This effectively wipes clean everything that was there before.

Here are the respective classes, interfaces and methods that you must implement. Feel free to add any methods that you want. The ones listed here are only the minimal subset that must be provided.

public class Aquarium extends JFrame {
 public Aquarium(int width, int height)
 public Color getWaterColor()
 public Dimension getSize()
 public Graphics getGraphicsContext()
 public void addObject(AquariumObject ao)
 public void refresh(Graphics g) // Note that a Graphics parameter is required to use the updated AquariumTest!
				 // See the "double-buffering" section below for details
}

Here is the interface for an AquariumObject. Its source code is in the file AquariumObject.java. Again, you may add additional methods to the interface or to Aquarium.java if you wish, but you must keep the existing one so that your program will still work with our provided test file (explained below).

public interface AquariumObject {
 public void paint(Graphics g);
}

Here are two AquariumObjects that you must create. Also, feel free to create any other AquariumObject classes that you would like to add to make your aquarium look good.

public class Sand implements AquariumObject { // Simulates the
 // gravel or sand that sits on the bottom of an aquarium

 public Sand(int x, int y, int width) // The parameters specify
 // the bottom-center position of the sand within its
 // graphical context and the width specifies how wide it
 // should be. It should be relatively short too.
 public void paint(Graphics g) // Redraw the sand
}

public class Aerator implements AquariumObject { // Represents an
 // aquarium air bubbler

 public Aerator(int x, int y, int height) // The x and y parameters
 // denote the bottom center position of the aerator and the
 // height parameter specifies how high the bubbles should go
 // above that coordinate.
 public void paint(Graphics g) // Redraw the aerator. NOTE:
 // subsequent calls to paint should slightly change the
 // positions of bubbles so it looks like the aerator is running
 // and sending bubbles up to the surface.
}

OK, now that we've dealt with the background elements, we can provide the more fun elements, the aquarium's inhabitants.

For fish, we will have a superclass Fish that represents a stationary fish. There are two constructors. One is more tightly specified and the other is designed to be more random and free. Fish will have a subclass MovingFish that has the ability to swim around to different positions. The call setBounds() on Moving Fish is important to define the edges of the aquarium that they should bump up against but not go outside. The important difference on a MovingFish is that each subsequent call to paint() should slightly move the fish to a different position, thus giving the impression that the fish is swimming. Think about how fish move---don't just have it randomly wiggle. Be creative.

public class Fish implements AquariumObject {
 public Fish(Color c, Polygon p, int x, int y) // Use the
 // specified polygon as the fish outline. The coords are
 // relative to the x,y. Make it the given solid color.
 public Fish(int x, int y) // Create some random (but decent)
 // looking fish at the given position
 public void paint(Graphics g) // Draw the fish
}

public class MovingFish extends Fish implements AquariumObject {
 public MovingFish(Color c, Polygon p, int x, int y) // Use the
 // specified polygon as the fish outline. The coords are
 // relative to the x,y. Make it the given solid color.
 public MovingFish(int x, int y) // Create some random (but decent)
 // looking fish at the given position
 public void setBounds(int minx, int miny, int maxx, int maxy) // Defines
 // the boundaries for swimming
 public void paint(Graphics g) // Draw the fish
}

Feel free to define your own subclasses of Fish and/or MovingFish. You might create an AngelFish, CatFish or some such animal that has its own unique look and behavior. You can add more methods to these and the superclasses too, but the objects should be able to run using only the ones specified above as a minimal, but sufficient, subset.

In testing your program, we will use two example driver classes with main() in them. In the first, we will design a basic driver that looks much like the example below. This will test the basic minimal, functionality of your program. Source code for this file can be found in AquariumTest.java. Update (11/7/08): AquariumTest now uses double-buffering. The link points to the new version, see the "double-buffering" section below for details.

Remember, if you modify AquariumObject, your program must still work with AquariumTest.

The second class should be created by you. Call your class AquariumSimulation. In it, you should show off all the interesting and different features you added. For instance, you might create instances of any fish subclasses you created. Have fun with this one!
Double-Buffering

If you started the homework before 11/7/08, you may have noticed the aquarium tends to flicker badly if you have a lot of objects. The flickering is ok--you can turn in your program with the flickering for no penalty. However, I have updated AquariumTest.java to use double-buffering instead which should help smooth the animation. In order to use the new AquariumTest, you must modify your Aquarium's refresh method to take a Graphics object. If you've done the update method right, you should only need to update two lines in the method with the new parameter.

If you do not want to update your program to use the new file, you will not lose points. The old version is no longer available on T-Square but you can find the source code at the end of this assignment description. It doesn't matter which version of AquariumTest you choose, just be sure to turn in a version that compiles with your program.
Extra Credit

You can earn up to twenty additional points of extra credit on this assignment (i.e. the maximum score is 70/50) for creativity, innovative features, and generally going above and beyond the minimum requirements. Examples of additional features might include new decorations for the aquarium, fish that age and "die" after a while, controls to manipulate the aquarium (maybe a button to add more fish?), etc.

Here are even more ideas for other objects you might add to your aquarium:

public class UnderwaterPlant implements AquariumObject { // Represents
 // a plant. Feel free to make each one created have its
 // own unique appearance.

 public UnderwaterPlant(int x, int y, int width, int height)
 // The x and y parameters denote the bottom center coordinate
 // of the plant. The width and height denote the maximum size
 // this plant can be (smaller is OK).
 public void paint(Graphics g) // Redraw the plant
}

public class Crab implements AquariumObject {
 public Crab(int x, int y) // The x and y parameters denote the
 // bottom-center of the crab. You can make it some arbitrary
 // (possibly random) reasonable size.
 public void paint(Graphics g) // Draw the crab
}

and of course, feel free to create any other aquarium decorations you like. The more effort you demonstrate, the more extra credit you will earn (up to 20 additional points). Include a readme.txt file where you list out your additional features.
Turn-in Procedures

After you have finished your program, turn the files in via T-Square. You will be submitting multiple files, including the files provided to you (AquariumObject.java and AquariumTest.java). Please make sure they are named as shown below:

    * Aquarium.java
    * AquariumObject.java
    * AquariumTest.java
    * Sand.java
    * Aerator.java
    * Fish.java
    * MovingFish.java
    * AquariumSimulation.java
    * Any other classes that you create for use in the assignment
    * If you added extra features, include a readme.txt file listing them.

Make sure you have turned in ALL files required for your program to compile! You should be able to download your submission from T-Square and compile and run it without any additional files.
Source code for the original, non-buffered AquariumTest.java

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class AquariumTest {
 private final int DELAY = 20;
 private Aquarium aquarium;
 private Fish[] fish;
 private Graphics g;
 private Timer timer;
 private int count = 0;

 public static void main(String[] args) {
 AquariumTest at = new AquariumTest();
 at.start();
 }

 public void start() {
 int[] x = {0, 30, 40, 50, 60, 70, 90, 100, 115,
 130, 115, 100, 90, 70, 60, 50, 40, 30, 0, 15};
 int[] y = {5, 15, 10, 7, 0, 7, 12, 15, 22, 25, 28, 35, 40,
 43, 50, 43, 40, 35, 45, 25};

 aquarium = new Aquarium(800,600);
 g = aquarium.getGraphicsContext();

 Sand s = new Sand(400,600,800);
 aquarium.addObject(s);

 Aerator a = new Aerator(700, 550, 550);
 aquarium.addObject(a);

 aquarium.refresh();

 Polygon poly = new Polygon(x, y, x.length);
 fish = new Fish[4];
 fish[0] = new Fish(280, 120);
 fish[1] = new Fish(new Color(234,200,167), poly, 560, 400);
 fish[2] = new MovingFish(315, 567);
 ((MovingFish)fish[2]).setBounds(0,0,800,600);
 fish[3] = new MovingFish(new Color(214,30,230), poly, 700, 120);
 ((MovingFish)fish[3]).setBounds(0,0,800,600);

 timer = new Timer(DELAY, new AnimListener());
 timer.start();
 }

 public void nextFrame() {
 aquarium.refresh();
 for (int i=0; i<fish.length; i++)
 fish[i].paint(g);
 }

 private class AnimListener implements ActionListener {

 public void actionPerformed(ActionEvent ae) {
 nextFrame();

 count++;
 if (count == 1000)
 timer.stop();
 }
 }
}