CPSC 124: Lab 5
Introduction to Classes

JAVA IS "OBJECT ORIENTED." This means that
programs are written by creating classes and using them to make objects.
Each object has its own data and behaviors, which are determined by the
class to which it belongs. When you are trying to write an object-oriented
program, you should look for conceptual "objects" in the problem you are
trying to solve, and you should represent those objects as software objects
in your program. In this way, the structure of the program can reflect the
real-world structure of the problem it is supposed to solve.

In this lab, you will work with classes and objects in two ways.
In Part 1, you will write a simple class that represents statistical
information about a set of numbers. In Part 2, you will use some the
predefined classes from the AWT to write an Applet.

Note: I have upgraded
CodeWarrior from version 9 to version 10. Version 10 has some significant
improvements in its implementation of Java. If you open a project file
from version 9 using the new version of CodeWarrior, you'll be asked if
you want to "convert the project." Just say yes. (I've already
upgraded all the project folders on the Math/CS Server.)

Part 1: Making a Class

For this part of the lab, you will write a class. You should start
with a new copy of the "Java Console Ap Starter" for the file
server. Create a new file containing your class, and add it to the
project. For your main program, you can use the sample main()
routine, given below. The only thing you need to turn in is a print-out
of the class file that you write. It should, of course, be properly
commented, indented, etc.

Every object is constructed based on some class. The object is
said to be a member or
instance of that class. The class specifies
what types of data the object will contains and what methods are available
for manipulating that data.

Recall that a class is just a list of variable declarations and method
definitions. The variables and methods that are not declared to
be static will become part of each object that is constructed based on
the class.

For the first part of this class, you will write a class named StatCalc
that can be used for statistical analysis of a set of numbers. The idea
is that you can create an object of type StatCalc and then
"feed" the numbers into that object one-by-one. The object
can then be queried to determine three statistical data about the numbers:
the mean (that is, the average) of the numbers,
the standard deviation, and the count
of the numbers.

Here is an example of a main program that uses the StatCalc class.
(If you are smart, you will just cut-and-paste this example from Netscape
into your program!)

Your assignment for this part of the lab is to write the Class StatCalc
with instance methods enter(), getCount(), getMean(),
and getSD(). It is not necessary for objects of type StatCalc
to store a list of all the numbers entered. All the information you need
can be stored in three instance variables:

count, which is the number of numbers that have been entered so far,

sum, which is the sum of all the numbers that have been entered so far, and

sumSquares, which is the sum of the squares of all the numbers that
have been entered so far.

(These should be private instance variables to protect
them from malicious change by entities outside the class.) Your enter()
method should simply make the appropriate changes to count, sum,
and sumSquares. (That is, it should add one to count, add
the number to sum, and add the square of the number to sumSquares.)
The getCount() simply returns the value of
count. The getMean() returns the average value, which is
computed by dividing the sum by the count. The getSD()
method returns the so-called "population standard deviation" of the numbers,
which is computed as: the square root of (1.0/count) * (sumSquares - count *
average2). (The standard deviation contains information about how "spread out"
the data is around the average value.)

By the way, you might take a closer look at
CodeWarrior 10 editing windows. In particular, you'll
find some useful buttons at the top left of the windows, as shown
in the example. When you click on any of these buttons and hold the
mouse down, you get a pop-up menu. The button on the left, labeled "h",
is a list of classes used by the class you are editing. By selecting
a class from that list, you can open the file where that class is defined.
The next button, labeled "{}", is even more useful. It contains
a list of the methods defined in the file you are editing. Selecting a
method from this list will take you directly to that method. This is
a very easy way to navigate your way around a long class file.
You might try out this button on your StatCalc class, to see
how it works.

Part 2: Your First Applet

You probably think of an applet as a small Java program that
runs in a rectangle on a page in a Web browser. Technically, though,
an applet is an object, in the sense of object-oriented programming.
It does not have a main() routine. Instead, it has methods
for responding to certain events that
can occur in a graphical user interface. Events include things like
mouse clicks, key presses, and selecting an item from a menu.
The "system" -- for example, the Web browser in which the
applet is running -- detects the events and calls the appropriate
method in the applet so that the applet can respond to the event.

To program an applet, you have to write a class to define the
applet's behavior. The class will be used by the system to create
an applet object, and it's the applet object that actually appears on
the screen. (In fact, you could have several instances of the same
applet on a Web page. Each instance is a separate object, but
all the instances belong to the same class.) Since an applet
is an object, its behavior is defined by instance methods rather than
static methods, and any data used by the applet should be stored in
instance variables.

(A new applet class "extends"
an existing class named Applet. This means that much of the
behavior of the new applet class is inherited
from the basic Applet class, and therefore does not have to be re-written.
This idea of inheritance is one of the most fundamental concepts
in object-oriented programming.)

There are several standard methods that you can include in an
applet to react to various events. The ones that you will use in
this lab are:

public void init() { // This is called when the applet is
. // first created, to give it a chance
. // to set itself up and initialize its
. // instance variables.
}
public void paint(Graphics g) {
. // This is called when the applet needs to
. // be redrawn, for example because it was hidden
. // behind another window, or because some other
. // method has called the repaint() method.
}
public boolean mouseDown(Event evt, int x, int y) {
. // This is called when the user clicks the mouse at the
. // point (x,y). (0,0) is at the top left of the applet;
. // x measures pixels from left to right; and y measures
. // pixels from top to bottom. You can ignore the Event
. // parameter, but it has to be there when you write the method.
return true; // Return true to system, to indicate that the
} // event has been handled.
public boolean mouseDrag(Event evt, int x, int y) {
. // This is called when the user moves the mouse while
. // holding down the mouse button. (x,y) gives the new
. // location of the mouse.
return true; // Return true to system, to indicate that the
} // event has been handled.
public boolean action(Event evt, Object arg) {
. // Called when the user performs certain actions,
. // such as clicking on a button or selecting an item
. // from a pop-up menu.
}

You must understand that all these routines are called by the
system at the appropriate times. You define the method to say what
happens when the event occurs. You will hardly ever call these routines
yourself.

For this part of the lab, you should use the folder "Lab 5 Applet"
from the file server. Copy the folder onto your computer, open the
project file, and look at the file, "FirstApplet.java". This
file defines a simple applet. You should read the comments on the applet
and try running it. (Note that when you "run" an applet
in CodeWarrior, it looks for an HTML file in the project. The HTML
file defines which applet is to be run and how big its window is to
be. You'll learn more about this in future labs. For now, just don't
change the name of the applet class or any of the settings in the
CodeWarrior Preferences.)

You will find that the Applet lets you move a little red square around
in the applet by clicking with the mouse. It also lets you make the square
bigger by clicking on a button.

Your assignment, after you have tried
the sample applet is to improve it in two ways:

First, let the user drag the square.
That is, if the user holds down the mouse button and moves the mouse,
then the square should follow the movement of the mouse.

Second, add three more buttons to the applet. One button will be
used to return the square to its original size, after it has been
made big. The next button will be used to change the color of the square
to green. And the last button will be used to change the color back to
red.

Turn in a print out of the class file for your applet. Since your
assignments are beginning to exceed my ability to check your programs just
by reading them, I would also like a copy of your entire CodeWarrior
project so that I can try running your applet if necessary.
Please name your project folder with your last name and copy it
into "Eck's Drop Box" on the file server. (If you have a
lab partner, please put both last names on the folder.)

The CodeWarrior Debugger

As a last exercise, which you should do on your own time, if necessary,
you should start getting acquainted with the CodeWarrior "debugger".
There is no exercise to turn in for this part of the lab. However,
as you begin to write more complicated programs, you will find the debugger
more and more useful. It's a good idea to start working with it now.

A "debugger" is used as an aid in finding and eliminating
bugs in a program. You can use the debugger to stop your program
in the middle of its execution and inspect the values of the variables.
You can also step through the program one instruction at a time and
watch what happens in detail.

The CodeWarrior debugger is reasonably easy to use. Just choose
the "Enable Debugger" command from the Project menu. Then
the "Run" command will change to "debug". When you
choose this Debug command, both your program and the debugger will
be started up. You'll see a window that looks like this (I've labeled
some of the important features):

Your program is displayed in the bottom part of the window. You should
set one or more breakpoints in your program.
Then click on the "Go" button to begin executing the program.
As the program is executed, when the computer encounters a breakpoint,
it will stop executing and you will have a chance to look at the variables.
Then you can either click on the "Go" button to resume execution
of the program, or click on the "Step" button to execute just
the next instruction. (The debugger has a lot of other advanced features.
You can learn about them as you become more experienced with it.)

Often you want to set a breakpoint in a file other than your main
program file. The debugger has another window that can be used to
view other classes and to set breakpoints in them. This second window
looks like this (Again, I've labeled some of the parts of the window):

You should try using the debugger to catch your StatCalc class
in the act of entering a number into the data set. Open your
StatCalc project. Turn on the debugger with the Enable Debugger
command. Use the Debug command to run the program. Set the debugger's
second window to set a breakpoint in the enter() method of
your class. Then click on the Go button. When the program stops at the
breakpoint, try stepping through the method to see how it works.

You should keep in mind that the debugger is itself a very complicated
program. When you run a Java program with debugging enabled, there are
actually four different programs involved: the program you wrote,
the Java interpreter, the CodeWarrior IDE, and the debugger. Each of
these programs can have its own windows, so the screen can get pretty
crowded. Just try not to panic!

By the way, after you have enabled the debugger, if you want to simply
run your program without using the debugger, just hold down the option
and select the "Run" command from the Project menu.