Overview

This lab lets you have fun with Java's rich graphics features while exploring the important idea of inheritance in programming. At the end of the lab period, you should have fish of your own design swimming in the aquarium you saw in lecture. For a look at what you're shooting for, click here.

You will write three classes for this lab (don't be alarmed -- they're not long), and copy one other class that you will modify.:

1. The applet.  As always, the applet creates the things that need to show up on the screen, puts them together in the right way, and responds when a user presses a button.
2. The Fish class itself   This is the one you're copying; the part you may modify is how it's drawn.
3. A subclass of Fish   You've already seen an example of this in lecture: the GillFish class. This will inherit all the features of your basic class, then add to them.
4. A subclass of the subclass   Example from lecture: FinFish. This carries over everything from your first subclass (which in turn carried over everything from Fish), and adds new stuff to it.

Getting Started

You should begin this lab by starting up your X windows program and getting a telnet window on your screen like you have for the other labs. Make sure you switch to your "public_html" directory like you usually do by typing:

cd public_html

Fish Class

First, you'll create a basic fish so you'll have something to test your program on later. To help things go along a little faster, a simple version of the Fish class is already typed up, you'll need to make some modifications to it later on in the lab, but for now you can use it as is. To copy the file to your public_html directory, type the following command into your telnet window:

cp ~srr1/public_html/Fish.java ~/public_html/Fish.java

Once you have the file copied, you can go ahead and open it up in xemacs. You will probably want to change this code to personalize your fish a little bit. At this point you probably won't want to make too many changes, just a simple change of colors or something along those lines. You can, and should, come back to this part once you have your aquarium up and running on the web to make some changes to the fish, but for now you just want to have a working Fish class. Examples of changes you might want to make:

• draw Method   This is where you'll make the most changes. You may want your Fish to be differently shaped, colored, etc. You might want to use this method to draw a basic seahorse, in which case your draw will look much different from this one.
• A summary of the DrawingPad class   The drawingPad is a specialized version of the canvas you used last week, and saw in lecture, that makes it easier to do this labs. Go to the reference sheet to see a list of the drawingPad methods you'll need to use.
• Size   The bounds on the size of the Fish are set in the contructor method, with the lines h = 50; and w = 100;. That doesn't mean that every fish on the screen will be 50 x 100, because the Aquarium automatically scales each fish (no pun intended) randomly to generate a nice variety. What it does mean is that all your subsequent drawing has to be done based on a 50 x 100 scale, so be very careful in resetting these values.

The Applet

Now that you have a fish to play around with, you can develop the part of the program that will display it: the applet. Open a new file in xemacs. Start off with the standard import lines at the top, and the normal first line in which you name your class. If you need some help, look back at your past labs. That first line is going to get a little longer this week: at its end (after implements ActionListener) type this:

OK, now back to normal. Go ahead and type the left curly-brace, and get ready for . . .

DECLARATIONS

• Buttons: one for each kind of fish you can create (the basic Fish (or whatever yours is) and the two types you'll be making later in the lab), and a Clear button. The fish Buttons should be labeled more descriptively than in the example. For instance, you might have "Basic Fish", "Cool Fish" and "Really Cool Fish" as Button labels. Don't just use "Fish 1", "Fish 2", and "Fish 3". Also, remember to use good coding style in naming your Buttons, so you can remember what they do throughout the program.
• Aquarium: fortunately, you don't have to write the aquarium from scratch. We've supplied it for you as part of the awb package, so you can use it in the same way you'd use a StringField or an IntField. Declare one, naming it aqua. Yes, you have to name it aqua.
• Thread: don't ask, just type this line ...
  
  Thread animator = null;

The following two methods are among those things that just have to be in the program to make the animated graphics work. Simply copy these two methods after declaring the buttons, aquarium, and thread, and before the init section.

 public void start()
 {
     animator = new Thread(this);
     animator.start();
 }

 public void run()
 {
     while(true) 
     {
        aqua.draw();
        try {Thread.sleep(20);} catch (InterruptedException e){}
     }
 }

• First line as usual: public void init()
• Construct four new Buttons and a new Aquarium. The Aquarium constructor takes no parameters.

• Your Aquarium has to be given a size before it can be added to the screen. That means you need to use a method of Aquarium called resize(int,int). For instance, if you declared an Aquarium named aqua and you want it to be 500 pixels wide and 350 pixels high, you should put this line next:

  aqua.resize(500,350);

• Now add everything to the screen, as usual, and close out init() with a right curly brace.

Go ahead and write the regular first line.

Remember, since the purpose of your actionPerformed() is to respond to user buttons clicks, its basic structure consists of an if statement for each button. You'll do two of those conditionals now (for the basic fish and the Clear button), then write your own fish, then come back and write the conditionals to put them on the screen.

• The first conditional:   Start off with the standard if line checking to see if source equals one of your Buttons, in this case the Button to create a basic Fish. If it does, you know the user just sent your program a signal to put a new Fish in the Aquarium. Here's how to do that:

  • Declare a Fish, then construct a new Fish and assign it to the variable you just declared. Nothing tricky here; it's just like the process for Buttons or TextFields, only in a different place. Remember, if your basic class is named Seahorse, you need to declare and construct a Seahorse instead of a Fish (etc...).

  • Now that you have a Fish in hand (so to speak), you can put it in the Aquarium using the addFish method of the Aquarium class. For instance, if you declared a Fish named basicFish and have an Aquarium named aqua, your next line will look like this:

    aqua.addFish(basicFish);

    The name of this method stays the same no matter what the name of your class is.

  • Now, return, and close the first if block.
• The second conditional is for the Clear button. Its body need only make a call to your Aquarium's clear() method and return true.
• Put the final return after the end of the second conditional

Now compile your class. IMPORTANT: Since you're working with a number of classes, you must select the xemacs buffer containing you applet before you compile it. After the class is compiled, you will want to make an html page to hold the applet. The page is the same as usual:

<html>
<body>
<applet code="FishTank.class" HEIGHT="350" WIDTH="500">
</applet>
</body>
</html>

Writing a subclass of Fish

The essential point of inheritance in Java is that a subclass inherits everything about its superclass, then adds something extra. It's a way to save both on quantity of code and complexity of design. You know inheritance is going on when you see the keyword extends in the first line of a class; you can think of extends as equivalent to "inherits from".

To really grasp the practical value of inheritance, it helps to look at examples. Here's a subclass of Fish, named GillFish

import java.awt.*;
import awb.*;

public class GillFish extends Fish
{

  public GillFish()
  {
    super();
  }

  public void draw(DrawingPad dp)
  {
    super.draw(dp);

    dp.setColor(Color.red);
    dp.drawLine(70,15,80,40);
    dp.drawLine(65,15,75,40);
    dp.drawLine(60,15,70,40);
  }
}

What you have to write

First of all, as a practical matter you should know that every class you write has to be contained in its own file. So, you should open another new file in xemacs now, and save it as whatever you named your subclass, plus a .java at the end.

You have to create, from scratch, a subclass that looks very much like GillFish. Here's what you need to change:

• Name   You must, of course, name your class something other than GillFish, and use that name throughout.
• extends   This class must extend your first class; that is, if you named your first class Seahorse, the first line of this class will end with extends Seahorse instead of extends Fish.
• Draw method   The other obvious difference is in draw. Your class must keep the first line in the body of draw (super.draw(dp)). After that, everything else will change to reflect how you choose to decorate your Fish.
• Don't underestimate the importance of having a good looking fish!. By the time you're done with this lab, you should have gained substantial experience with Java's drawing commands, so you're expected to use most of the drawing tools available to you and do something neat. After all these labs are completed, the TAs will select the best 5 or so fish from the class and award their creators extra credit, and showcase the fish on the big screen during a lecture.

The next class you have to write will be almost exactly like the one you just did, with two notable exceptions. First, its name and draw method will be different, just as the first subclass's name and draw were different from those of a basic Fish. Second, this new subclass extends the first subclass, not Fish. So if your first subclass was called GillFish and you want to call this one FinFish, the first line of this class should be:

public class FinFish extends GillFish

Other than that, base this subclass closely on the first subclass, with a different draw method.

Wrapping up the applet

Now that you have a couple of new kinds of fish of your own, you need to write code to handle the buttons that create them. In xemacs, switch back to the first file you were working on, the one containing your applet, and go to the action method. You have two more conditional statements to write, each of which will look very similar to the first conditional. That's because they all exist to put new fish in the Aquarium. In fact, the only difference is that instead of declaring and constructing a new object of the Fish class, you'll declare and construct a new object of your subclass (for one of the conditionals) and a new object of the subclass of your subclass (for the other). You still use addFish to put your new subclass objects in the Aquarium.

That's it. Once you've written those two other conditionals, you can compile and run your program until it works and your fish look the way you want them to. Remember that you have to recompile every time you make a change in the code in order to see the effect of the change.