Overview of JMenuBar, JMenu, and JMenuItem
Before you can create a menu,
you need to know something about the three core menu classes: JMenuBar, JMenu, and JMenuItem.
These form the minimum set of classes needed to construct a main menu for an
application. JMenu and JMenuItem are also used by popup menus.
Thus, these classes form the foundation of the menu system.
As mentioned, JMenuBar is essentially a container for
menus. Like all components, it inherits JComponent
(which inherits Container and Component). It has only one
constructor, which is the default
constructor. Therefore, initially the menu bar will be empty, and you will need
to populate it with menus prior to use. Each application has one and only one
JMenuBar defines several methods, but often you will only need to use one: add( ). The add( ) method adds
a JMenu to the menu bar. It is shown
JMenu add(JMenu menu)
Here, menu is a JMenu instance
that is added to the menu bar. A reference to the menu is returned. Menus are
positioned in the bar from left to right, in the order in which they are added.
If you want to add a menu at a specific location, then use this version of add( ), which is inherited from Container:
Component add(Component menu, int idx)
Here, menu is added at the index specified by idx. Indexing begins at 0, with 0 being the left-most menu.
In some cases, you might want
to remove a menu that is no longer needed. You can do this by calling remove( ), which is inherited from Container. It has these two forms:
void remove(Component menu) void remove(int idx)
Here, menu is a reference to the menu to remove, and idx is the index of the menu to remove. Indexing begins at zero.
Another method that is
sometimes useful is getMenuCount( ),
shown here: int getMenuCount( )
It returns the number of
elements contained within the menu bar.
JMenuBar defines some other methods that you might find helpful in
specialized applications. For
example, you can obtain an array of references to the menus in the bar by
calling getSubElements( ). You can
determine if a menu is selected by calling isSelected(
). Once a menu bar has been created and populated, it is added to a JFrame by calling
setJMenuBar( ) on the JFrame instance.
(Menu bars are not added to the
content pane.) The setJMenuBar( ) method is shown here:
void setJMenuBar(JMenuBar mb)
Here, mb is a reference to the menu bar. The menu bar will be displayed
in a position determined by the look and feel. Usually, this is at the top of
JMenu encapsulates a menu, which is populated with JMenuItems. As mentioned, it is derived from JMenuItem.
This means that one JMenu can be a
selection in another JMenu. This
enables one menu to be a submenu of another. JMenu defines a number of constructors. For example, here is the
one used in the examples in this chapter:
This constructor creates a
menu that has the title specified by name.
Of course, you don’t have to give a menu a name. To create an unnamed menu, you
can use the default constructor:
Other constructors are also
supported. In each case, the menu is empty until menu items are added to it.
JMenu defines many methods. Here is a brief description of some commonly
used ones. To add an item to the
menu, use the add( ) method, which
has a number of forms, including the two shown here:
JMenuItem add(JMenuItem item) JMenuItem add(Component item, int idx)
Here, item is the menu item to add. The first form adds the item to the
end of the menu. The second form adds the item at the index specified by idx. As expected, indexing starts at
zero. Both forms return a reference to the item added. As a point of interest,
you can also use insert( ) to add
menu items to a menu.
You can add a separator (an
object of type JSeparator) to a menu
by calling addSeparator( ), shown
void addSeparator( )
The separator is added onto
the end of the menu. You can insert a separator into a menu by calling insertSeparator( ), shown next:
void insertSeparator(int idx)
Here, idx specifies the zero-based index at which the separator will be
You can remove an item from a
menu by calling remove( ). Two of
its forms are shown here:
void remove(JMenuItem menu) void remove(int idx)
In this case, menu is a reference to the item to
remove and idx is the index of the
item to remove.
You can obtain the number of items
in the menu by calling getMenuComponentCount(
), shown here:
int getMenuComponentCount( )
You can get an array of the
items in the menu by calling getMenuComponents(
), shown next: Component[ ] getMenuComponents( )
An array containing the
components is returned.
JMenuItem encapsulates an element in a menu. This element can be a selection
linked to some program action, such
as Save or Close, or it can cause a submenu to be displayed. As mentioned, JMenuItem is derived from AbstractButton, and every item in a
menu can be thought of as a special kind of button. Therefore, when a menu item
is selected, an action event is generated. (This is similar to the way a JButton fires an action event when it
is pressed.) JMenuItem defines many
constructors. The ones used in this chapter are shown here:
JMenuItem(String name) JMenuItem(Icon image) JMenuItem(String name, Icon image) JMenuItem(String name,
int mnem) JMenuItem(Action action)
The first constructor creates
a menu item with the name specified by name.
The second creates a menu item that displays the image specified by image. The third creates a menu item
with the name specified by name and
the image specified by image. The
fourth creates a menu item with the name specified by name and uses the keyboard mnemonic specified by mnem. This mnemonic enables you to
select an item from the menu by pressing the specified key. The last
constructor creates a menu item using the information specified in action. A default constructor is also
Because menu items inherit AbstractButton, you have access to the
functionality provided by AbstractButton.
One such method that is often useful with menus is setEnabled( ), which you can use to enable or disable a menu item.
It is shown here:
void setEnabled(boolean enable)
If enable is true, the menu
item is enabled. If enable is false, the item is disabled and cannot