We return to object-oriented programming in this lab (to the sound of much applause, I'm sure!); we will have one more lab with a calculational flavor (Hisses? Boo's?) before we settle into a "programming-centered" mode for the rest of the semester.

More specifically, in this lab we will start to use objects as a mechanism to organize our code. The basic ideas behind objects will be covered in lecture to support this; you should also read the Wu text, Chapter 1, if you haven't done so already.

Contents

• Basic instructions
• Tips and hints
• What to expect for your demo

Basic instructions

In order to fulfill the assignment, you should write a Java applet, just as in Lab 2, which stick figures on the screen. This time around, however, you are requiredto organize your code in terms of objects and classes (well, at least one class, anyway). I will of course examine your code during your demo in order to verify this structure, but I will also arrange the demo so as to test how easily you can modify your program to produce different specific drawings.

The basic class you will create can be called "Figure", "StickFigure" or "Person" (note that the initial capital letter is required). Each object of this class will represent an individual person (abstractly) or a stick figure on the screen (more concretely, if phosphorescing pixels can be called "concrete"). You will create new objects (figures) dynamically using the new construct (see lecture or the Wu text). This will allow you to easily create multiple figures on the screen.

Each figure or person should come equipped with some basic descriptive information (corresponding to instance variables) and some basic capabilities (corresponding to methods). For the purposes of the assignment, these should include at least the following (feel free to add more once you have the basic assignment done):

• A name

  Each person should be "born" with a name when their object is created with new. Use a java String to store the name, as in:

  String name;

• A position

  This should be represented as x and y co-ordinates (two integers, stored as Java ints.

• An age

  This should also be represented as an integer (i.e., a whole number of years). We will make the (incredibly unrealistic) assumption that a person's rate of growth is uniform and linear until age 18, and that all people are thereafter the exact same height (say approximately 60 pixels). In other words, when a person is drawn, you can use their age divided by 18 as a ratio for scaling their drawing, unless they are over 18, in which case you should use a scale of 1:1.

• A means of drawing itself

  A figure object should be able to draw itself on the Java applet window in the appropriate position and scale. Notice that the position and scale (as determined by their age) are kept internal to the figure object, and therefore need not be passed in as parameters to the drawing method.

  As a special feature to make figure recognition easier, each figure should be self-labeling with its name and age, placed in some reasonable position relative to the figure itself (e.g., above or below the figure by a few pixels).

Your demo code should create and draw at least 3 figures, with names and ages, at least one of which should be under age 18. By way of example, you might draw the following picture:

Tips and hints

• Use the Applet template, not an empty project

  Once again, just as in Lab 2, you should remember to use the AWT Applet template when you create your project. And just as in Lab 2, you will want to then replace the comment at the top of the Applet1.java file as well as insert your own paint method into the class near the bottom (but before the final closing brace).

• You will need a separate class for StickFigures

  In order to staisfy the requirements of the assignment, you will need to declare a separate class for StickFigures; this will be in a separate file called StickFigure.java. This file also needs to be in your project, so that you can create and use new objects of the StickFigure class.

• You must pass the Graphics parameter to the drawing method

  In order to use the Graphics libraries line and oval drawing methods, you must have access to the Graphics object which represents the window in which the figures are to be drawn (i.e., the one associated with the applet you are running). The easiest way to do this is probably to pass the parameter graphics in to the method which does the figure drawing; note that you will also need to declare this parameter in the "header" for the drawing method. If you use a separate method for the drawing demo (i.e., separate from the standard paint method), you will have to pass the Graphics parameter through that method to the drawing method.

  By way of example, (portions of) your code might look like this:

  public void paint(Graphics graphic) {
  
  	// code for paint method here:
  	
  	demo(graphic);
  
  }
  
  public void demo(Graphics graphic) {
  
  	// code for demo method here:
  	
  	StickFigure sam = new StickFigure(100,100,"Sam Jones",36);
  	
  	// ...
  	
  	sam.draw(graphic);
  	
  }
  

• Be sure to include documentation!

  Just as in Lab 2, you should be sure to include proper documentation (comments) with your program. Look to the sample programs in the class code directory for ideas on what form comments might take.

What to expect for your demo

You should have your program complete and ready to go by the time you ask for a demo. You should also bring a completed demo form (I will pass out another copy before the due date).

As I mentioned above, I will be asking you to make some modifications to your program "on the fly" in order to test your understanding of the use of classes, objects and methods. You should be prepared for this. Also, with this program, more of the categories for points listed on the left of the demo form are becoming relevant, so you may wish to re-read them. Please ask me if you have any questions about what the point categories mean.