With this lab we return fully to object-oriented programming in Java. More specifically, we will continue to explore object-oriented design and Java language features through the vehicle of simple drawings. With this lab, however, we will begin to animate our drawings, thus taking advantage of what we have learned thus far about objects and classes, variables, loops and arrays, as well as our experience with Java Graphics library concepts and methods.

Starting with this lab we will also begin to leave problem specifications more open-ended (and thus less well-defined) and to give fewer instructions about implementation than in previous labs. As you mature as a programmer, you will naturally be asked to do more independent decision-making about the design of your projects. Along with this we will grant you a bit more freedom to determine the character of your projects.

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, along the lines of Lab 2 and Lab 4, which simulates some simple physical principles. More specifically, you should design an animation of some graphical objects in a way which will reflect motion and forces including, for example, friction and gravity. There is a sample animation linked in below to give you an idea of the sort of applet you might write, but you should feel free to explore your own ideas in order to make the project more fun and interesting. Although there will be some minimum requirements, they will be fairly loose with regard to the content of your animation. We will, however, be more demanding about the structure of your code.

The sample applet is available here: it implements a simple animation in which some colored objects bounce around in a "room". Each of the animated objects is a Ball, and each Ball in turn comes with certain properties which are maintained within the object itself:

• x and y co-ordinates

  These are integers telling where the ball is at any time.

• x and y components of velocity

  These are integers which keep track of how fast the ball is moving, and in which direction (the two components combine to give the full picture of the velocity).

• a color and a size

  Size is simply an integer (in terms of pixels); color is one of the java.lang.Color package colors (see your text for more information on how to access these; remember to use a line at the top of your class to "include" the package).

• a Graphics component where the ball "lives"

  Java's library structure demands that we keep track of a variable which tells which "window" we are drawing in (strictly speaking, "window" has a different technical meaning, but you can imagine that the Graphics object is essentially a kind of window). This is naturally kept inside the object itself, after having been passed in as a parameter at the time of the object's construction.

Furthermore, each Ball object comes with several methods, which are implemented as part of the Ball class:

• the Ball constructor

  The constructor allows new Balls to be created: values are passed in to "fill in" the slots represented by the values described above.

• draw

  This is a parameter-less method which simply draws a filled oval at the Ball's current position. It also changes the current color using setColor first; you should remember to reset the current color whenever you draw so as to get the intended effect (another option is to store the current color, change it temporarily, and then restore it again when you are done).

• move

  This method uses the velocity of the Ball to update its position. Furthermore, it adds a constant value to represent the force of gravity to the y component of the velocity (think back to physics and calculus: these constant additions will yield a second-order effect through the updating of the velocity). Finally, the method also checks to see if the Ball has hit a wall and, if it has, reverse its direction with an appropriate "penalty" for energy lost to the bounce. These bounce effects arise when the Ball reaches the left or right wall or the ceiling or floor, affecting the corresponding components of velocity.

Tips and hints

• Use the Applet template, not an empty project

  Once again, just as in Labs 2 and 4, 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 should have separate classes for Balls and for some main driving method (at least!)

  In order to satisfy the requirements of the assignment, you will need to declare a separate class for Balls; this will be in a separate file called Ball.java. This file also needs to be in your project, so that you can create and use new objects of the Ball class. The "main" method that drives your code can either be placed in your Applet class or can be called from there, but implemented as a separate class, as to your taste. You are of course welcome to add further class structure in order to bring out the best design in your code.

• 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.

• Be sure to include documentation!

  Just as in all your programming labs, 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.

Still having trouble putting it all together?

If the above information and discussion from lecture and lab is still leaving you confused, consider the following "sketches" of the BouncyBall demo I wrote:

They show one approach to defining files, classes and methods for the implementation of the project.

After this sketch is implemented in actual code, the following refinements would add new capabilities (shown here in red), including multiple Balls, color and special effects (e.g., Balls bouncing off walls):

Here are some text files which show how these sketches could be put into Java format (with all the details missing, though!):

BouncyBall.java

Ball.java

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.