Lab 10 In-Class: Graphical User Interfaces
Vote Counter - Using Buttons
The files VoteCounter.java
and VoteCounterPanel.java contain
a slightly modified version of the PushCounter program in
Listings 4.10 & 4.11 of the text (pages 192-194).
VoteCounterPanel.java is the same as in pre-lab.
Recall that the program counts the
number of times the button is pushed; it assumes ("pretends")
each push is a vote for Blue.
- Save the files to your directory, then compile the program
and run it to see how it works. Resize the
window to see the effect on the components.
- In your xterm window use the ls command to see the files
you have. In addition to the java source code files you should
see 3 bytecode files: VoteCounter.class, VoteCounterPanel.class,
and VoteCounterPanel$VoteButtonListener.class. The latter is the
bytecode for the VoteButtonListener class that is nested inside
the VoteCounterPanel class.
- Modify the program so that there are two candidates to vote for --
Blue and Red. To do this you need to do the following (most of this
you did on paper in pre-lab):
- Add instance variables for Red -- a vote counter,
a button, and a label. Initialize these variables in the
constructor for the panel.
- Add the button and label for Red to the panel.
- Add the VoteButtonListener object voteListener to the
button using the addActionListener method.
- Modify the actionPerformed method in the
VoteButtonListener class so it checks to see which button
generated the event (that is, which button was pushed)
and then updates the appropriate counter and displays the
To do this you need to use the getSource method
for event objects. The event object is passed as a parameter
to the actionPerformed method (the formal parameter name
of the ActionEvent object is event).
The getSource method returns
a reference to the component that generated the event so
you can compare it to your components as in the example on
page 261 (267).
- Compile and run the program.
- Adding Some Color Modify the panel so that its
color is blue if the Blue button is ahead in the number of "votes"
and red if Red is ahead and magenta if it is a tie. Do the following:
- In actionPerformed, after the count has been updated and
add a statement to set the background
color of the panel based on who is ahead. All Java components have
void setBackground (Color color)
that changes thebackground color
- Also, change the color of the labels so they clearly show
up -- use different colors to go with each background (you can
choose the colors).
Components have a setForeground method that is analogous to the
setBackground method. The setForeground method changes the
color of the text in labels and in buttons.
- Compile and test your program. Be sure your colors look good and
that the labels are visible. If you wish you can also change the
foreground and/or background colors of the buttons.
Using TextFields - Computing Body Mass Index
The files Fahrenheit.java and
the example program in Listings 4.12 & 4.13 of the text (pages 196 - 198).
The program converts temperatures in Fahrenheit to the Celsius
equivalent. The user enters a temperature in the text field and when
ENTER is pressed the Celsius equivalent is computed and displayed.
Pressing ENTER on a text field generates an action event so
the program must implement the ActionListener interface. Do the
- Save the program files to your directory, compile the program and run
it to see how it works.
- Study the code in FahrenheitPanel.java noting the following:
- The actionPerformed method uses the getText method
to get the information out of the text field. That information is
returned as a String.
- The string from the text field must be converted to a number
(in this case an int) for calculations. The parseInt method
in the Integer class does this.
- The toString method in the Integer class is used to convert
the Celsius temperature back to a String. An alternate way to do this
would be "" + celsiusTemp.
In this exercise you will write a similar program to compute a
person's Body Mass Index.
Body Mass Index (BMI) is a measure of weight that takes height into account.
Generally, a BMI above 25 is considered high, that is, likely to indicate
that an individual is overweight. BMI is calculated as follows for both
men and women:
(703 * weight in pounds) / (height in inches)2
File BMI.java contains the main program
that creates the frame for the GUI panel and adds the panel to the
content pane of the frame. The file BMIPanel.java
contains a skeleton for the GUI to
calculate BMI. Since there are two input values needed (the height and
weight) this program will not respond to the user pressing ENTER on a
Instead, we will put a button on the panel for the user to press
to trigger the calculation.
So, the user enters his or her height and weight and presses a
"Calculate BMI" button; the program then displays
the user's BMI. Much of the framework has been done for you, but you will need
to fill in code.
Do the following (follow the instructions and the comments in the program):
In the constructor for the panel you need to do the following (put
your code for each immediately after the corresponding comment in the
- JLabels have already been created to identify the height and weight
textfields. You need to create (instantiate) the
JLabels for the output, and to hold the
actual BMI. (NOTE: You need to use the variables that have already
- Create JTextFields to hold the person's height in inches and weight in pounds.
- Create an appropriately labeled JButton for the user to press to calculate the BMI.
- Create a BMIListener and make it listen for the button to be pressed.
Note that the listener is added to the button, not
the textfields, so the BMI is computed only when the button is pressed,
not when the
user presses Enter on the textfields.
- Add the height label and textfield to the panel.
Note that the components will appear on the panel
in the order
in which you add them (left to right, top to bottom).
- Add the weight label and textfield to the panel.
- Add the button to the panel.
- Add the label identifying the result and the label holding the result to
In the actionPerformed method of BMIListener:
- Get the text from the height and weight textfields and store
the results in the String variables provided.
- Use Integer.parseInt to convert the text to integer values, and store
them in the int values provided.
- Calculate the BMI from the height and weight values (use double
- Use Double.toString to convert the BMI to a string, and store the string in
the result label.
Compile the BMI program and run it.
- Add code to the BMIPanel
to let the user have some idea of what
their BMI means. You need to either modify the JLabel that displays
the BMI or add a new JLabel. Your program should include a message based
on the following: a BMI less than 19 indicates the person is underweight,
a BMI between 19 and 25 (inclusive) means a healthy weight, a BMI between
26 and 30 (inclusive) indicates the person is overweight, and a BMI over
30 indicates the person is very overweight. NOTE: Use an if to
choose the appropriate message.
Using Buttons to Move a Snowman
Buttons can be used for all sorts of things including modifying a
graphics scene. In this exercise you will use buttons to move
a snowman around on a graphics panel. The file
Snowman.java contains the class defining a graphical snowman (from
an earlier lab), the file MoveSnowman.java
contains the main program that creates the frame for the GUI and
the file SnowmanPanel.java contains
the class that sets up the GUI. Save these files to your lab10 directory
then do the following:
- Note that the SnowmanPanel class has some constants and 5
instance variables - 4 buttons and a Snowman object. Currently the
constructor only does a few things: it instantiates the Snowman object and the
buttons, creates a separate panel for the buttons to go on, and it
sets the size and color of the main panel.
Also note that a panel uses a method named
paintComponent rather than paint for drawing.
Compile and run the program - all you will see is the
- Complete the GUI by adding the following to the SnowmanPanel constructor
(as indicated in the comments):
- Declare and instantiate a MoveListener and then add it to listen
for events on each button.
- Add the buttons to the button panel.
- Add the button panel to the main panel.
- Compile and run the program to see how things look (your buttons
won't do anything yet).
- Now we need to make the Snowman move when the buttons are pressed.
That requires doing the following:
- Add a move method to the Snowman class. The method
should have two parameters of type int. The first should represent
the amount to add to the middle instance variable (so this will move
the Snowman to the right if the actual parameter
is positive and move it left
if the number is negative); the second should represent the amount
to add to the top instance variable (a positive value will move the
Snowman down; a negative value will move the Snowman up). The method
should return nothing.
- Add an if statement to the actionPerformed method in
the MoveListener class that checks to see which button was clicked
and moves the Snowman 20 pixels in the appropriate direction. Note
that the reference to the component that generated the event is
in the variable source. To "move" the Snowman you need
to invoke your move method with the correct parameters.
- Compile and run the program. Make sure all buttons are moving the
Snowman in the correct direction.
A GUI-based ATM Machine
In lab 9 we wrote a program that simulated a simple ATM machine. That
program had a command-line interface - the user typed reponses in
at a command line prompt. In this exercise you will create a simple
GUI-based ATM machine. You will need the following files:
Account.java, the bank account class;
ATM.java, the main program for the GUI;
ATMPanel.java, the GUI panel.
Open ATMPanel.java in emacs and do the following:
- Create the components and listeners as instructed by the
comments in the program. When you add the components to the panel
add them in the following order: the welcome label, the label telling
the user to enter the amount, the text field for the amount, the label
instructing the user to click the appropriate button, the buttons,
and the label giving the balance. (Note: Don't do actionPerformed
yet - we'll get the GUI looking ok first.)
- Compile and run the program to see what it looks like. Not
too pretty! This is what the default flow layout looks like.
- There are many ways to make things look better. The one we will
use is nested panels (see Section 3.10 in the text, pages 144-146). We'll
divide the panel into 4 subpanels (and specify the size of each), then
add those to the main panel (which has a size specified). Do this
- Declare and instantiate a JPanel named welcomePanel. Set its
size (the width should be the constant WIDTH - you choose an appropriate
height). Add the welcome label to the panel.
- Declare and instantiate a JPanel named amtPanel. Set its
size and add both the label for the text field and the text field
- Similarly declare and instantiate a JPanel, appropriately sized,
containing the two
- Finally declare and instantiate a JPanel, appropriately sized,
containing the balance label.
- Instead of adding the individual components to the main panel
add the four subpanels.
- Compile and run the program to see how it looks. Make necessary
modifications, including setting colors for the panels, to make things
- Implement the actionPerformed method in the ChoiceListener
class. The method should get the amount from the text field and
convert it to a double using the parseDouble method in the
Double class. Then the method needs to see which button was clicked
and, using methods from the Account class, perform the appropriate
action. Finally use the setText method to
update the balance label (remember to use the formatter to
format the new balance).
Hand in printouts for VoteCounterPanel.java, BMIPanel.java, SnowmanPanel.java,
Tar your directory and email the tar file to your instructor with a
subject of cpsc120 lab10