Programming Exercises
For Chapter 7
THIS PAGE CONTAINS programming exercises based on
material from Chapter 7 of this on-line
Java textbook. Each exercise has a link to a discussion of one possible solution of that
exercise.
Exercise 7.1:
Exercise 5.2 involved a class,
StatCalc.java, that could compute
some statistics of a set of numbers. Write an applet that uses
the StatCalc class to compute and display statistics of
numbers entered by the user. The applet will have an instance
variable of type StatCalc that does the computations.
The applet should include a TextField
where the user enters a number. It should have four labels that
display four statistics for the numbers that have been entered:
the number of numbers, the sum, the mean, and the standard deviation.
Every time the user enters a new number, the statistics displayed
on the labels should change. The user enters a number by
typing it into the TextField and pressing return.
There should be a "Clear" button that clears out all the data.
This means creating a new StatCalc object and resetting
the displays on the labels. My applet also has an "Enter" button
that does the same thing as pressing the return key in the
TextField. (Recall that a TextField generates
an ActionEvent when the user presses return, so your applet
should register itself to listen for ActionEvents from the
TextField.) Here is my solution to this problem:
See the solution!
Exercise 7.2:
Write an applet with a TextArea where the use can enter
some text. The applet should have a button. When the user clicks
on the button, the applet should count the number of lines in the
user's input, the number of words in the user's input, and the
number of characters in the user's input. This information should
be displayed on three labels in the applet. Recall that if
textInput is a TextArea, then you can get the
contents of the TextArea by calling the function
textInput.getText(). This function returns a String
containing all the text from the TextArea. The number of
characters is just the length of this String. Lines
in the String are separated by the new line character,
'\n', so the number of lines is just the number of new line characters
in the String, plus one. Words are a little harder to
count. Exercise 3.4 has
some advice about finding the words in a String. Essentially,
you want to count the number of characters that are first characters
in words. Here is my applet:
See the solution!
Exercise 7.3:
The RGBColorChooser applet
lets the user set the red, green, and blue levels in a color by
manipulating scroll bars. Something like this could make a useful
custom component. Such a component could be included in a program to allow
the user to specify a drawing color, for example. Rewrite the
RGBColorChooser as a component. Make it a subclass of
Panel instead of Applet. Instead of doing the
initialization in an init() method, you'll have to do it
in a constructor. The component should have a method, getColor(),
that returns the color currently displayed on the component.
It should also have a method, setColor(Color c), to set
the color to a specified value. Both these methods would be useful
to a program that uses your component.
In order to write the setColor(Color c) method, you
need to know that if c is a variable of type Color,
then c.getRed() is a function that returns an integer
in the range 0 to 255 that gives the red level of the color.
Similarly, the functions c.getGreen() and c.getBlue()
return the blue and green components.
Test your component by
using it in a simple applet that sets the component to a random
color when the user clicks on a button, like this one:
See the solution!
Exercise 7.4:
In the Blackjack game BlackjackGUI.java
from Exercise 6.8,
the user can click on the "Hit", "Stand", and "NewGame" buttons
even when it doesn't make sense to do so. It would be better
if the buttons were disabled at the appropriate times. The
"New Game" button should be disabled when there is a game
in progress. The "Hit" and "Stand" buttons should be disabled
when there is not a game in progress. The instance variable
gameInProgress tells whether or not a game is in progress,
so you just have to make sure that the buttons are properly
enabled and disabled whenever this variable changes value.
Make this change in the Blackjack program. This applet uses
a canvas class, BlackjackCanvas, to represent the board.
You'll have to do most of your work in that class. In order to
manipulate the buttons, you'll need instance variables
to refer to the buttons. One problem you have to deal with
is that the buttons are used in both the applet class
and the canvas class.
I strongly advise using a subroutine to set the value of
the gameInProgress variable. Then the subroutine can take responsibility for
enabling and disabling the buttons.
Recall that if bttn is a variable of type
Button, then bttn.setEnabled(false)
disables the button and bttn.setEnabled(true) enables
the button.
See the solution!
[A working applet can be found here.]
Exercise 7.5:
Building on your solution to the preceding exercise, make it possible for the user
to place bets on the Blackjack game. When the applet starts, give the user $100.
Add a TextField to the strip of controls along the bottom of the applet.
The user can enter the bet in this TextField. When the game begins,
check the amount of the bet. You should do this when the game begins, not
when it ends, because several errors can occur: The contents of the TextField
might not be a legal number. The bet that the user places might be more money than
the user has, or it might be <= 0. You should detect these errors and show an
error message instead of starting the game. The user's bet should be an
integral number of dollars. You can convert the user's input into an integer, and
check for illegal, non-numeric input, with a try...catch statement of
the form
try {
betAmount = Integer.parseInt( betInput.getText() );
}
catch (NumberFormatException e) {
. . . // The input is not a number.
// Respond by showing an error message and
// exiting from the doNewGame() method.
}
It would be a good idea to make the TextField uneditable while the game
is in progress. If betInput is the TextField, you can make it
editable and uneditable by the user with the commands
betAmount.setEditable(true) and betAmount.setEditable(false).
In the paint() method, you should include commands to display the amount
of money that the user has left.
There is one other thing to think about: The applet should not start a new game
when it is first created. The user should have a chance to set a bet amount
before the game starts. In the constructor for the canvas class, you should not
call doNewGame(). You might want to start the game with the
message "Welcome to Blackjack".
See the solution!
[A working applet can be found here.]
Exercise 7.6:
The StopWatch component from Section 7.4
displays the text "Timing..." when the stop watch is running. It would
be nice if it displayed the elapsed time since the stop watch
was started. For that, you need to create a Thread. Add
a Thread to the original source code, StopWatch.java,
to display the elapsed time in seconds. Create the thread in
the mousePressed() routine when the timer is started.
Stop the thread in the mousePressed() routine when the timer
is stopped. The elapsed time won't be very accurate anyway, so just
show the integral number of seconds. You only need to set the text a
few times per second. In my run() method, I insert a delay of 100 milliseconds
after I set the text. Here is an applet that tests my solution
to this exercise:
See the solution!
Exercise 7.7:
The applet at the end of Section 7.8 shows
animations of moving symmetric patterns that look something like
the image in a kaleidascope. Symmetric patterns are pretty.
Make the SimplePaint3 applet do symmetric, kaleidascopic
patterns. As the user draws a figure, the applet should be able to
draw reflected versions of that figure to make symmetric pictures.
The applet will have several options for the type of symmetry
that is displayed. The user should be able to choose one of
four options from a Choice menu. Using the "No symmetry" option,
only the figure that the user draws is shown. Using "2-way symmetry",
the user's figure and its horizontal reflection are shown.
Using "4-way symmetry", the two vertical reflections are added.
Finally, using "8-way symmetry", the four diagonal reflections are
also added. Formulas for computing the reflections are given below.
The source code SimplePaint3.java
already has a putFigure() subroutine that draws all the figures.
You can add a putMultiFigure() routine to draw a figure and some or
all of its reflections. putMultiFigure can call the existing
putFigure to draw each figure. It decides which reflections to
draw based on the setting of the symmetry Choice menu. Where the mousePressed,
mouseDragged, and mouseReleased methods call
putFigure, they should call putMultiFigure instead.
If (x,y) is a point in a component that is width pixels wide
and height pixels high, then the reflections of this point are
obtained as follows:
The horizontal reflection is (width - x, y)
The two vertical reflections are (x, height - y) and (width - x, height - y)
To get the four diagonal reflections, first compute the diagonal reflection of (x,y) as
a = (int)( ((double)y / height) * width );
b = (int)( ((double)x / width) * height );
Then use the horizontal and vertical reflections of the point (a,b):
(a, b)
(width - a, b)
(a, height - b)
(width - a, height - b)
(The diagonal reflections are harder than they would be if the canvas were square.
Then the height would equal the width, and the reflection of (x,y) would just
be (y,x).)
To reflect a figure determined by two points, (x1,y1) and (x2,y2),
compute the reflections of both points to get the reflected figure.
This is really not so hard. The changes you have to make to the source
code are not as long as the explanation I have given here.
Here is my applet. Don't forget to try it with the symmetry Choice
menu set to "8-way Symmetry"!
See the solution!
Exercise 7.8:
Turn your applet from the previous exercise into a stand-alone
application that runs in a Frame. This is not an easy
exercise, since the material on frames in Section 7.7 is
sort of sketchy. The information is there if you read carefully.
(But I won't think too badly
of you if you just look at the solution.)
As another improvement, you can add an "Undo" button.
When the user clicks on the "Undo" button, the previous drawing operation will
be undone. This just means returning to the image as it was before the
drawing operation took place. This is easy to implement, as long
as we allow just one operation to be undone. When the off-screen canvas,
OSC, is created, make a second off-screen canvas, undoBuffer,
of the same size. Before starting any drawing operation,
copy the image from OSC to undoBuffer. You can do this with
the commands
Graphics undoGr = undoBuffer.getGraphics();
undoGr.drawImage(OSC, 0, 0, null);
When the user clicks "Undo", just swap the values of OSC
and undoBuffer and repaint. The previous image will appear
on the screen. Clicking on "Undo" again will "undo the undo".
Here is a button that
opens the paint program in its own window. (You don't have to
write an applet like this one. Just open the frame in the
program's main() routine.)
See the solution!
