Solution for
Programming Exercise 7.4
THIS PAGE DISCUSSES ONE POSSIBLE SOLUTION to
the following exercise from this on-line
Java textbook.
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 nested 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 will have to use instance variables
to refer to the buttons.
I strongly advise writing a subroutine that can be called
whenever it is necessary 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
JButton, then bttn.setEnabled(false)
disables the button and bttn.setEnabled(true) enables
the button.
Discussion
Here is my applet:
In the original applet, the button variables are declared in the init() method
of the applet, where the buttons are created. There are no instance variables that refer to the buttons, so
it is not possible to do anything with the buttons outside the init()
method. For this exercise, references to the buttons must be stored in instance
variables. These variables are required in order to call the buttons'
setEnabled() methods.
There are several ways that this could work. We could put the variables in
the BlackjackCanvas class; then the init() method of the applet could refer
to them through a variable of that class. Since the variable, board,
refers to the canvas, the init() method would refer to a button named
hit in the canvas as board.hit. It would set up the
button with commands such as:
board.hit = new JButton("Hit!");
board.hit.addActionListener(board);
buttonPanel.add(board.hit);
However, since the BlackjackCanvas class is nested inside the
applet class, we might as well just declare the button variables in the
main class. Since BlackJackCanvs is a nested, non-static
class, the board will automatically have access to the instance
variables in the main class.
The applet uses instance variables hit, stand, and
newGame to refer to the buttons. The buttons must be enabled
and disabled whenever the value of the variable gameInProgress
changes. As recommended in the exercise, I wrote a method for
changing the value of this variable. This method also enables and disables
the buttons to reflect the state of the program:
public void setGameInProgress(boolean inProgress) {
// This method should be called whenever the value of
// the gameInProgress variable needs to be changed. It
// changes the value of the variable and also enables/disables
// the buttons to reflect the state of the game.
gameInProgress = inProgress;
if (gameInProgress) {
hit.setEnabled(true);
stand.setEnabled(true);
newGame.setEnabled(false);
}
else {
hit.setEnabled(false);
stand.setEnabled(false);
newGame.setEnabled(true);
}
}
Once this routine is available, then any line in the old program that
said "gameInProgress = false;" should be changed to
"setGameInProgress(false);". And any line that
said "gameInProgress = true;" should be changed to
"setGameInProgress(true);". In this way, we can be sure that
the buttons are always properly enabled and disabled. (You should also check
that they are in the correct states when the applet first appears. They are,
because the doNewGame() routine is called as part of the setup,
and this routine always calls either "setGameInProgress(false);"
or "setGameInProgress(true);".)
You should understand why I used a subroutine to set the value of
gameInProgress. Every time gameInProgress changes,
each of the buttons has to be enabled or disabled. That's three
extra lines of code each time the program says gameInProgress = true
or gameInProgress = false. We can avoid some extra typing by
calling the subroutine. Furthermore, if we always call the subroutine to
set the value of gameInProgress, we can be sure that the
states of the buttons will always be set correctly to match the value
of gameInProgress.
That's essentially all there is to this exercise, but my first attempt
had a bug. The applet wouldn't start properly because of a NullPointerException.
The problem was that the constructor in the BlackjackCanvas class calls doNewGame()
which calls setGameInProgress. In order for this to work, the buttons
must already exist. Otherwise, the value of hit is null in the
setGameInProgress method, and
the statement "hit.setEnabled(true);" generates the error
because hit doesn't
refer to any object. In order to fix this problem, I just had to
create the buttons before creating the canvas in the applet's init()
method.
The Solution
Changes from BlackjackGUI are shown in red.
/*
In this applet, the user plays a game of Blackjack. The
computer acts as the dealer. The user plays by clicking
"Hit!" and "Stand!" buttons.
The programming of this applet assumes that the applet is
set up to be about 466 pixels wide and about 346 pixels high.
That width is just big enough to show 2 rows of 5 cards.
The height is probably a little bigger than necessary,
to allow for variations in the size of buttons from one platform
to another.
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class BlackjackGUI2 extends JApplet {
/* Declare the buttons that the user clicks to control the
game. These buttons are set up in the init() method and
are used in the nested class BlackjackCanvas. */
JButton hit, stand, newGame;
public void init() {
// The init() method creates components and lays out the applet.
// A BlackjackCanvas occupies the CENTER position of the layout.
// On the bottom is a panel that holds three buttons. The
// BlackjackCanvas object listens for events from the buttons
// and does all the real work of the program.
setBackground( new Color(130,50,40) );
hit = new JButton( "Hit!" );
stand = new JButton( "Stand!" );
newGame = new JButton( "New Game" );
// I had to move these three lines to the start of the init()
// method because the constructor of the BlackjackCanvas
// class refers to the buttons (indirectly, by
// calling doNewGame()). This led to a NullPointerException
// when the constructor was called before the buttons
// were created.
BlackjackCanvas board = new BlackjackCanvas();
getContentPane().add(board, BorderLayout.CENTER);
JPanel buttonPanel = new JPanel();
buttonPanel.setBackground( new Color(220,200,180) );
getContentPane().add(buttonPanel, BorderLayout.SOUTH);
hit.addActionListener(board);
buttonPanel.add(hit);
stand.addActionListener(board);
buttonPanel.add(stand);
newGame.addActionListener(board);
buttonPanel.add(newGame);
} // end init()
public Insets getInsets() {
// Specify how much space to leave between the edges of
// the applet and the components it contains. The background
// color shows through in this border.
return new Insets(3,3,3,3);
}
// --- The remainder of this class consists of a nested class ---
class BlackjackCanvas extends JPanel implements ActionListener {
// A nested class that displays the card game and does all the work
// of keeping track of the state and responding to user events.
Deck deck; // A deck of cards to be used in the game.
BlackjackHand dealerHand; // Hand containing the dealer's cards.
BlackjackHand playerHand; // Hand containing the user's cards.
String message; // A message drawn on the canvas, which changes
// to reflect the state of the game.
boolean gameInProgress; // Set to true when a game begins and to false
// when the game ends.
Font bigFont; // Font that will be used to display the message.
Font smallFont; // Font that will be used to draw the cards.
BlackjackCanvas() {
// Constructor. Creates fonts and starts the first game.
setBackground( new Color(0,120,0) );
smallFont = new Font("SansSerif", Font.PLAIN, 12);
bigFont = new Font("Serif", Font.BOLD, 14);
doNewGame();
}
public void actionPerformed(ActionEvent evt) {
// Respond when the user clicks on a button by calling
// the appropriate procedure. Note that the canvas is
// registered as a listener in the BlackjackGUI class.
String command = evt.getActionCommand();
if (command.equals("Hit!"))
doHit();
else if (command.equals("Stand!"))
doStand();
else if (command.equals("New Game"))
doNewGame();
}
public void setGameInProgress(boolean inProgress) {
// This method should be called whenever the value of
// the gameInProgress variable needs to be changed. It
// changes the value of the variable and also enables/disables
// the buttons to reflect the state of the game.
gameInProgress = inProgress;
if (gameInProgress) {
hit.setEnabled(true);
stand.setEnabled(true);
newGame.setEnabled(false);
}
else {
hit.setEnabled(false);
stand.setEnabled(false);
newGame.setEnabled(true);
}
}
void doHit() {
// This method is called when the user clicks the "Hit!" button.
// First check that a game is actually in progress. If not, give
// an error message and exit. Otherwise, give the user a card.
// The game can end at this point if the user goes over 21 or
// if the user has taken 5 cards without going over 21.
if (gameInProgress == false) {
// This should be impossible, since the Hit button is disabled
// when the game is not is progress, but it doesn't hurt to check.
message = "Click \"New Game\" to start a new game.";
repaint();
return;
}
playerHand.addCard( deck.dealCard() );
if ( playerHand.getBlackjackValue() > 21 ) {
message = "You've busted! Sorry, you lose.";
setGameInProgress(false);
}
else if (playerHand.getCardCount() == 5) {
message = "You win by taking 5 cards without going over 21.";
setGameInProgress(false);
}
else {
message = "You have " + playerHand.getBlackjackValue() + ". Hit or Stand?";
}
repaint();
}
void doStand() {
// This method is called when the user clicks the "Stand!" button.
// Check whether a game is actually in progress. If it is,
// the game ends. The dealer takes cards until either the
// dealer has 5 cards or more than 16 points. Then the
// winner of the game is determined.
if (gameInProgress == false) {
message = "Click \"New Game\" to start a new game.";
repaint();
return;
}
setGameInProgress(false);
while (dealerHand.getBlackjackValue() <= 16 && dealerHand.getCardCount() < 5)
dealerHand.addCard( deck.dealCard() );
if (dealerHand.getBlackjackValue() > 21)
message = "You win! Dealer has busted with " + dealerHand.getBlackjackValue() + ".";
else if (dealerHand.getCardCount() == 5)
message = "Sorry, you lose. Dealer took 5 cards without going over 21.";
else if (dealerHand.getBlackjackValue() > playerHand.getBlackjackValue())
message = "Sorry, you lose, " + dealerHand.getBlackjackValue()
+ " to " + playerHand.getBlackjackValue() + ".";
else if (dealerHand.getBlackjackValue() == playerHand.getBlackjackValue())
message = "Sorry, you lose. Dealer wins on a tie.";
else
message = "You win, " + playerHand.getBlackjackValue()
+ " to " + dealerHand.getBlackjackValue() + "!";
repaint();
}
void doNewGame() {
// Called by the constructor, and called by actionPerformed() if
// the use clicks the "New Game" button. Start a new game.
// Deal two cards to each player. The game might end right then
// if one of the players had blackjack. Otherwise, gameInProgress
// is set to true and the game begins.
if (gameInProgress) {
// If the current game is not over, it is an error to try
// to start a new game.
message = "You still have to finish this game!";
repaint();
return;
}
deck = new Deck(); // Create the deck and hands to use for this game.
dealerHand = new BlackjackHand();
playerHand = new BlackjackHand();
deck.shuffle();
dealerHand.addCard( deck.dealCard() ); // Deal two cards to each player.
dealerHand.addCard( deck.dealCard() );
playerHand.addCard( deck.dealCard() );
playerHand.addCard( deck.dealCard() );
if (dealerHand.getBlackjackValue() == 21) {
message = "Sorry, you lose. Dealer has Blackjack.";
setGameInProgress(false);
}
else if (playerHand.getBlackjackValue() == 21) {
message = "You win! You have Blackjack.";
setGameInProgress(false);
}
else {
message = "You have " + playerHand.getBlackjackValue() + ". Hit or stand?";
setGameInProgress(true);
}
repaint();
} // end newGame();
public void paintComponent(Graphics g) {
// The paint method shows the message at the bottom of the
// canvas, and it draws all of the dealt cards spread out
// across the canvas.
super.paintComponent(g); // fill with background color.
g.setFont(bigFont);
g.setColor(Color.green);
g.drawString(message, 10, getSize().height - 10);
// Draw labels for the two sets of cards.
g.drawString("Dealer's Cards:", 10, 23);
g.drawString("Your Cards:", 10, 153);
// Draw dealer's cards. Draw first card face down if
// the game is still in progress, It will be revealed
// when the game ends.
g.setFont(smallFont);
if (gameInProgress)
drawCard(g, null, 10, 30);
else
drawCard(g, dealerHand.getCard(0), 10, 30);
for (int i = 1; i < dealerHand.getCardCount(); i++)
drawCard(g, dealerHand.getCard(i), 10 + i * 90, 30);
// Draw the user's cards.
for (int i = 0; i < playerHand.getCardCount(); i++)
drawCard(g, playerHand.getCard(i), 10 + i * 90, 160);
} // end paint();
void drawCard(Graphics g, Card card, int x, int y) {
// Draws a card as a 80 by 100 rectangle with
// upper left corner at (x,y). The card is drawn
// in the graphics context g. If card is null, then
// a face-down card is drawn. (The cards are
// rather primitive.)
if (card == null) {
// Draw a face-down card
g.setColor(Color.blue);
g.fillRect(x,y,80,100);
g.setColor(Color.white);
g.drawRect(x+3,y+3,73,93);
g.drawRect(x+4,y+4,71,91);
}
else {
g.setColor(Color.white);
g.fillRect(x,y,80,100);
g.setColor(Color.gray);
g.drawRect(x,y,79,99);
g.drawRect(x+1,y+1,77,97);
if (card.getSuit() == Card.DIAMONDS || card.getSuit() == Card.HEARTS)
g.setColor(Color.red);
else
g.setColor(Color.black);
g.drawString(card.getValueAsString(), x + 10, y + 30);
g.drawString("of", x+ 10, y + 50);
g.drawString(card.getSuitAsString(), x + 10, y + 70);
}
} // end drawCard()
} // end nested class BlackjackCanvas
} // end class BlackJackGUI2
[ Exercises
| Chapter Index
| Main Index
]
