Chapter 11. Graphical User Interfaces
Graphical user interfaces, or GUIs,
represent an excellent example of software modularity and reuse. GUIs
are almost always assembled from libraries of predefined building
blocks. To Motif programmers on Unix systems, these GUI building
blocks are known as widgets. To Windows
programmers, they are known as controls. In
Java, they are known by the generic term
components, because they are all subclasses of
java.awt.Component.
In Java 1.0 and
1.1, the standard library of GUI components was AWTthe package
java.awt and its subpackages. There is debate as
to what the letter A stands for in this acronym, but
"WT" stands for
"windowing toolkit." In practice,
it is always called AWT. In addition to GUI components, the AWT
includes facilities for drawing graphics, performing
cut-and-paste-style data transfer, and other related operations. On
most platforms, AWT components are implemented using the
operating-system's native GUI system. That is, AWT
components are implemented on top of Windows controls on Windows
operating systems, on top of Motif widgets on Unix systems, and so
on. This implementation style led to a least-common-denominator
toolkit, and, as a result, the AWT API is not as complete and full
featured as it should be.
Java 1.2 introduced a new library of GUI
components known as Swing. Swing consists of the
javax.swing package and its subpackages. Unlike
the AWT, Swing has a platform-independent implementation and a
state-of-the-art set of features. Although Swing first became a core
part of the Java platform in Java 1.2, a version of Swing is
available for use with Java 1.1 platforms. Swing has largely replaced
the AWT for the creation of GUIs, so we'll focus on
Swing in this chapter. Note that Swing defines a new, more powerful
set of GUI components but retains the same underlying GUI programming
model used by the AWT. Thus, if you learn to create GUIs with Swing
components, you can do the same with AWT components.
There
are four basic steps to creating a GUI in Java:
Create and configure the components You create a GUI component just like any other object in Java, by
calling the constructor. You'll need to consult the
documentation for individual components to determine what arguments a
constructor expects. For example, to create a Swing
JButton component that displays the label
"Quit", simply write: JButton quit = new JButton("Quit"); Once you have created a component, you may want to configure it by
setting one or more properties. For example, to specify the font a
JButton component should use, you can write: quit.setFont(new Font("sansserif", Font.BOLD, 18)); Again, consult the documentation for the component you are using to
determine what methods you can use to configure the component. Add the components to a container All components must be placed within a
container. Containers in Java are all subclasses
of java.awt.Container. Commonly used containers
include JFrame and JDialog
classes, which represent top-level windows and dialog boxes,
respectively. The java.applet.Applet class, which
is subclassed to create applets, is also a container and can
therefore contain and display GUI components. A container is a type
of component, so containers can be, and commonly are, nested within
other containers. JPanel is a container that is
often used in this manner. In developing a GUI, you are really
creating a containment hierarchy: the top-level window or applet
contains containers that may contain other containers, which in turn
contain components. To add a component to a container, you simply
pass the component to the add( ) method of the
container. For example, you can add a quit button
to a "button box" container with
code like the following: buttonbox.add(quit); Arrange, or lay out, the components In addition to specifying which
components are placed inside of which containers, you must also
specify the position and size of each component within its container,
so that the GUI has a pleasing appearance. While it is possible to
hardcode the position and size of each component, it is more common
to use a LayoutManager object to lay out the
components of a container automatically according to certain layout
rules defined by the particular LayoutManager you
have chosen. We'll learn more about layout
management later in this chapter. Handle the events generated by the components The
steps described so far are sufficient to create a GUI that looks good
on the screen, but our graphical "user
interface" is not complete, because it does not yet
respond to the user. As the user interacts with the components that
make up your GUI using the keyboard and mouse, those components
generate, or fire, events. An event is simply an
object that contains information about a user interaction. The final
step in GUI creation is the addition of event
listenersobjects that are notified when an event is
generated and respond to the event in an appropriate way. For
example, the Quit button needs an
event listener that causes the application to exit.
We'll look at each of these topics in more detail in
the first few sections of this chapter. Then we'll
move on to more advanced GUI examples that highlight particular Swing
components or specific GUI programming techniques. As usual,
you'll want to have access to AWT and Swing
reference material as you study the examples. One such reference is
Java Foundation Classes in a Nutshell. You may
also find it helpful to read this chapter in conjunction with
Chapters 2 and 3 of that book.
|