Home Page
>
Creating a GUI with JFC/Swing
>
Using Swing Components
How to Use Buttons, Check Boxes, and Radio Buttons
To create a button,
you can instantiate one of the many classes that descend from the
AbstractButton class.
The following table shows the Swing-defined
AbstractButton subclasses
that you might want to use:
Note: If you want to collect a group of buttons into a row or column,
then you should check out
tool bars.
First, this section explains the basic button API
that AbstractButton defines —
and thus all Swing buttons have in common.
Next, it describes the small amount of API that
JButton adds to AbstractButton.
After that, this section shows you how to use specialized API
to implement check boxes and radio buttons.
Here is a picture of an application that displays three buttons:
Try this:
- Click the Launch button to run the Button Demo using
Java™ Web Start (download JDK 6).
Alternatively, to compile and run the example yourself,
consult the
example index.
- Click the left button.
It disables the middle button
(and itself, since it is no longer useful)
and enables the right button.
- Click the right button.
It enables the middle button
and the left button,
and disables itself.
As the ButtonDemo example shows,
a Swing button can display both text and an image.
In ButtonDemo,
each button has its text in a different place,
relative to its image.
The underlined letter in each button's text
shows the mnemonic — the keyboard alternative —
for each button.
In most look and feels,
the user can click a button by pressing the Alt key and the mnemonic.
For example, Alt-M would click the Middle button in ButtonDemo.
When a button is disabled,
the look and feel automatically generates
the button's disabled appearance.
However, you could provide an image to be substituted for the normal image.
For example, you could provide
gray versions of the images used in the left and right buttons.
How you implement event handling
depends on the type of button you use
and how you use it.
Generally, you implement an
action listener,
which is notified every time the user clicks the button.
For check boxes
you usually use an
item listener,
which is notified when the check box is selected or deselected.
Below is the code from
ButtonDemo.java
that creates the buttons in the previous example
and reacts to button clicks.
The bold code is the code
that would remain if the buttons had no images.
//In initialization code:
ImageIcon leftButtonIcon = createImageIcon("images/right.gif");
ImageIcon middleButtonIcon = createImageIcon("images/middle.gif");
ImageIcon rightButtonIcon = createImageIcon("images/left.gif");
b1 = new JButton("Disable middle button", leftButtonIcon);
b1.setVerticalTextPosition(AbstractButton.CENTER);
b1.setHorizontalTextPosition(AbstractButton.LEADING); //aka LEFT, for left-to-right locales
b1.setMnemonic(KeyEvent.VK_D);
b1.setActionCommand("disable");
b2 = new JButton("Middle button", middleButtonIcon);
b2.setVerticalTextPosition(AbstractButton.BOTTOM);
b2.setHorizontalTextPosition(AbstractButton.CENTER);
b2.setMnemonic(KeyEvent.VK_M);
b3 = new JButton("Enable middle button", rightButtonIcon);
//Use the default text position of CENTER, TRAILING (RIGHT).
b3.setMnemonic(KeyEvent.VK_E);
b3.setActionCommand("enable");
b3.setEnabled(false);
//Listen for actions on buttons 1 and 3.
b1.addActionListener(this);
b3.addActionListener(this);
b1.setToolTipText("Click this button to disable "
+ "the middle button.");
b2.setToolTipText("This middle button does nothing "
+ "when you click it.");
b3.setToolTipText("Click this button to enable the "
+ "middle button.");
...
}
public void actionPerformed(ActionEvent e) {
if ("disable".equals(e.getActionCommand())) {
b2.setEnabled(false);
b1.setEnabled(false);
b3.setEnabled(true);
} else {
b2.setEnabled(true);
b1.setEnabled(true);
b3.setEnabled(false);
}
}
protected static ImageIcon createImageIcon(String path) {
java.net.URL imgURL = ButtonDemo.class.getResource(path);
...//error handling omitted for clarity...
return new ImageIcon(imgURL);
}
Ordinary buttons —
JButton objects —
have just a bit more functionality
than the AbstractButton class provides:
You can make a JButton
be the default button.
At most one button in a top-level container
can be the default button.
The default button typically has a highlighted appearance
and acts clicked whenever the
top-level container has the keyboard focus
and the user presses the Return or Enter key.
Here is a picture of a dialog, implemented in the
ListDialog example,
in which the Set button
is the default button:
You set the default button
by invoking the setDefaultButton method
on a top-level container's root pane.
Here is the code that sets up the default button
for the ListDialog example:
//In the constructor for a JDialog subclass:
getRootPane().setDefaultButton(setButton);
The exact implementation of the default button feature
depends on the look and feel.
For example, in the Windows look and feel,
the default button changes to whichever button has the focus,
so that pressing Enter
clicks the focused button.
When no button has the focus,
the button you originally specified
as the default button becomes the default button again.
How to Use Check Boxes
The
JCheckBox class provides support for check box buttons.
You can also put check boxes in menus,
using the
JCheckBoxMenuItem class.
Because
JCheckBox
and
JCheckBoxMenuItem
inherit from AbstractButton,
Swing check boxes have all the usual button characteristics,
as discussed earlier in this section.
For example, you can specify images
to be used in check boxes.
Check boxes are similar to radio buttons
but their selection model is different, by convention.
Any number of check boxes in a group
— none, some, or all —
can be selected.
A group of radio buttons, on the other hand,
can have only one button selected.
file:///home/mb40549/ws/tutorial/src/uiswing/components/buttongroup.html
Here is a picture of an application that uses four check boxes
to customize a cartoon:
Try this:
- Click the Launch button to run the CheckBox Demo using
Java™ Web Start (download JDK 6).
Alternatively, to compile and run the example yourself,
consult the
example index.
- Click the Chin button or press Alt-c.
The Chin check box becomes unselected,
and the chin disappears from the picture.
The other check boxes remain selected.
This application has one item listener
that listens to all the check boxes.
Each time the item listener receives an event,
the application loads a new picture that reflects
the current state of the check boxes.
A check box generates one item event and one action event
per click.
Usually, you listen only for item events,
since they let you determine
whether the click selected or deselected the check box.
Below is the code from
CheckBoxDemo.java
that creates the check boxes in the previous example
and reacts to clicks.
//In initialization code:
chinButton = new JCheckBox("Chin");
chinButton.setMnemonic(KeyEvent.VK_C);
chinButton.setSelected(true);
glassesButton = new JCheckBox("Glasses");
glassesButton.setMnemonic(KeyEvent.VK_G);
glassesButton.setSelected(true);
hairButton = new JCheckBox("Hair");
hairButton.setMnemonic(KeyEvent.VK_H);
hairButton.setSelected(true);
teethButton = new JCheckBox("Teeth");
teethButton.setMnemonic(KeyEvent.VK_T);
teethButton.setSelected(true);
//Register a listener for the check boxes.
chinButton.addItemListener(this);
glassesButton.addItemListener(this);
hairButton.addItemListener(this);
teethButton.addItemListener(this);
...
public void itemStateChanged(ItemEvent e) {
...
Object source = e.getItemSelectable();
if (source == chinButton) {
//...make a note of it...
} else if (source == glassesButton) {
//...make a note of it...
} else if (source == hairButton) {
//...make a note of it...
} else if (source == teethButton) {
//...make a note of it...
}
if (e.getStateChange() == ItemEvent.DESELECTED)
//...make a note of it...
...
updatePicture();
}
How to Use Radio Buttons
Radio buttons are groups of buttons
in which,
by convention,
only one button at a time can be selected.
The Swing release supports radio buttons with the
JRadioButton and
ButtonGroup classes.
To put a radio button in a
menu, use the
JRadioButtonMenuItem class.
Other ways of displaying one-of-many choices are
combo boxes and
lists.
Radio buttons look similar to
check boxes,
but, by convention,
check boxes place no limits on how many items
can be selected at a time.
Because JRadioButton inherits from AbstractButton,
Swing radio buttons have all the usual button characteristics,
as discussed earlier in this section.
For example,
you can specify the image displayed in a radio button.
Here is a picture of an application that uses five radio buttons
to let you choose which kind of pet is displayed:
Try this:
- Click the Launch button to run the RadioButton Demo using
Java™ Web Start (download JDK 6).
Alternatively, to compile and run the example yourself,
consult the
example index.
- Click the Dog button or press Alt-d.
The Dog button becomes selected,
which makes the Bird button become unselected.
The picture switches from a bird to a dog.
This application has one action listener
that listens to all the radio buttons.
Each time the action listener receives an event,
the application displays the picture
for the radio button
that was just clicked.
Each time the user clicks a radio button
(even if it was already selected),
the button fires an
action event.
One or two
item events also occur —
one from the button that was just selected,
and another from the button that lost the selection (if any).
Usually, you handle radio button clicks using an action listener.
Below is the code from
RadioButtonDemo.java
that creates the radio buttons in the previous example
and reacts to clicks.
//In initialization code:
//Create the radio buttons.
JRadioButton birdButton = new JRadioButton(birdString);
birdButton.setMnemonic(KeyEvent.VK_B);
birdButton.setActionCommand(birdString);
birdButton.setSelected(true);
JRadioButton catButton = new JRadioButton(catString);
catButton.setMnemonic(KeyEvent.VK_C);
catButton.setActionCommand(catString);
JRadioButton dogButton = new JRadioButton(dogString);
dogButton.setMnemonic(KeyEvent.VK_D);
dogButton.setActionCommand(dogString);
JRadioButton rabbitButton = new JRadioButton(rabbitString);
rabbitButton.setMnemonic(KeyEvent.VK_R);
rabbitButton.setActionCommand(rabbitString);
JRadioButton pigButton = new JRadioButton(pigString);
pigButton.setMnemonic(KeyEvent.VK_P);
pigButton.setActionCommand(pigString);
//Group the radio buttons.
ButtonGroup group = new ButtonGroup();
group.add(birdButton);
group.add(catButton);
group.add(dogButton);
group.add(rabbitButton);
group.add(pigButton);
//Register a listener for the radio buttons.
birdButton.addActionListener(this);
catButton.addActionListener(this);
dogButton.addActionListener(this);
rabbitButton.addActionListener(this);
pigButton.addActionListener(this);
...
public void actionPerformed(ActionEvent e) {
picture.setIcon(new ImageIcon("images/"
+ e.getActionCommand()
+ ".gif"));
}
For each group of radio buttons,
you need to create a ButtonGroup instance
and add each radio button to it.
The ButtonGroup
takes care of unselecting the previously selected button
when the user selects another button in the group.
You should generally initialize a group of radio buttons
so that one is selected.
However, the API doesn't enforce this rule —
a group of radio buttons can have no initial selection.
Once the user has made a selection,
exactly one button is selected from then on.
There's no supported API for unselecting all the buttons.
The following tables list the commonly used
button-related API.
Other methods you might call,
such as setFont and setForeground,
are listed in the API tables in
The JComponent Class.
The API for using buttons falls into these categories:
Fine Tuning the Button's Appearance
| Method or Constructor
|
Purpose
|
void setHorizontalAlignment(int)
void setVerticalAlignment(int)
int getHorizontalAlignment()
int getVerticalAlignment() |
Set or get where in the button its contents should be placed.
The AbstractButton class allows
any one of the following values
for horizontal alignment:
RIGHT,
LEFT,
CENTER (the default),
LEADING, and
TRAILING.
For vertical alignment:
TOP,
CENTER (the default), and
BOTTOM.
|
void setHorizontalTextPosition(int)
void setVerticalTextPosition(int)
int getHorizontalTextPosition()
int getVerticalTextPosition() |
Set or get where the button's text should be placed,
relative to the button's image.
The AbstractButton class allows
any one of the following values
for horizontal position:
LEFT,
CENTER,
RIGHT,
LEADING, and
TRAILING (the default).
For vertical position:
TOP,
CENTER (the default), and
BOTTOM.
|
void setMargin(Insets)
Insets getMargin() |
Set or get the number of pixels between
the button's border and its contents.
|
void setFocusPainted(boolean)
boolean isFocusPainted() |
Set or get whether the button
should look different when it has the focus.
|
void setBorderPainted(boolean)
boolean isBorderPainted() |
Set or get whether the border of the button
should be painted.
|
void setIconTextGap(int)
int getIconTextGap()
|
Set or get the amount of space between the text and the icon
displayed in this button.
|
JSP
Servlets
Tomcat
mysql
Java
JSP
Servlets
Tomcat
mysql
Java
JSP
Servlets
Tomcat
mysql
Java
JSP
Servlets
Tomcat
mysql
Java
JSP at JSP.aldenWEBhosting.com
Servlets at servlets.aldenWEBhosting.com
Tomcat at Tomcat.aldenWEBhosting.com
mysql at mysql.aldenWEBhosting.com
Java at Java.aldenWEBhosting.com
Web Hosts Portal
Web Links
Web Links
Web Hosting
JSP Solutions Web Links
JSP Solutions Web Hosting
Servlets Solutions Web Links
Servlets Solutions Web Hosting
Web Links
Web Links
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
jsp hosting
servlets hosting
web hosting
web sites designed
cheap web hosting
web site hosting
myspace web hosting
