Download Slides

yes no Was this document useful for you?
   Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

GUIs in Java
Swing, Events
CS2110, SW Development Methods
MSD, Chapter 12
Lab Exercise
Why Study GUIs in CS2110
• First, why not?
– Complex topic, complex library
– Many classes, methods
– Hard to do this well initially
• Reasons we study GUIs
– Again, example of inheritance in a
framework, software reuse, etc.
– Event-driven programming
– An important form of program-control
• Swing is a Java library (framework) for
creating GUIs
– Part of a larger JFC (Java Foundation
– Replaces but uses an older library, AWT
– Another, newer alternative: SWT
– Used in Eclipse
• Swing apps will use look-and-feel of the
system they’re running on
– Or can be set by the program
Learning Swing
• Important things to learn
– Swing components
– E.g. buttons, text-fields, frames, etc.
– How to organize and arrange them
– Containers, layout managers
– How to make things change when
something happens
– Event-based programming
Containment Hierarchy
• Top-level container:
– place for other Swing components to paint
– e.g., JFrame, JDialog, Japplet
• Intermediate container:
– simplify positioning of atomic components
– e.g., JPanel, JSplitPane, JTabbedPane
Components and Containers
• See pages 809-816 in text
• All Swing GUI objects are Components
• Some are also Containers
– Example: JFrame, JPanel, etc
• You place other Components inside
– Example: a JFrame has buttons, text-fields, etc.
– Example: a JPanel is part of a window, in which
we organize GUI components
What We Do with Containers
• Add components to them
• Determine how these items will be
arranged on the screen
– Layout control
– We associate a Swing layout-manager with
each container
• Layout is very hard to do at the
– So we won’t sweat it in CS2110
• Atomic components:
– self-sufficient components that present
information to and get input from the user
– e.g., JButton, JLabel, JList, JComboBox,
JTextField, JTable
• Components
and containers:
– superclasses
and interfaces
– extends
and implements
© O’Reilly 1999
Top-Level Containers
• JFrame example:
– contains a single component JRootPane, which
has a JMenuBar (optional) and a content pane
– add non-menu components to its content panel
– theFrame.add( aButton )
– Pre Java 5.0
– theFrame.getContentPane().add( aButton )
Events and User Interaction
• Programs so far:
main() is called and runs to completion
• Swing programs:
– “main” class has (or may be) a JFrame
– main() sets up the GUI and ends
– Program keeps running, waiting for and
responding to “events”
– Button pressed, text typed, window closed, etc
– Program is event-driven
• Two approaches to event handling
– read-evaluation loop (client-written loop)
– notification-based (callbacks)
• Swing uses the 2nd approach
• Swing:
– objects communicate by “firing” and
“handling” events (event objects)
– (conventional method call)
– events are sent from a single source object
to one or more registered listener objects
• Swing:
– different event sources produce different
kinds of events
e.g., a JButton object, when clicked,
generates an ActionEvent object, which is
handled by an ActionListener (an object
whose class implements this interface)
MSD book, p. 837
• Handling:
– create a component
– e.g., a JButton
– add it to the GUI
– e.g., to a JPanel
– register a listener to be notified when the
component generates an event
– e.g., interface ActionListener
– define the callback method
– e.g., actionPerformed()
Event Handling
• class MyListener implements ActionListener {
public void actionPerformed( ActionEvent event ) {
// react to event
• …
// instantiate event listener
ActionListener listener = new MyListener();
// instantiate event source
JButton button = new JButton( “Hello” );
// register event listener with event source
button.addActionListener( listener );
Common Technique (e.g. Jigloo)
• Use anonymous class to create a
listener object “on the fly”
// register event listener with event source
button1.addActionListener( new ActionListener()
public void actionPerformed(ActionEvent evt)
handlerForButton1Press(evt); //see below
... // and later you write the handler method
public void handlerForButton1Press(evt) {
// your code to handle button press
What’s this? Java Anonymous
• There’s a Java technique called anonymous
– One of several types of nested class definition
– You’ll very often see it in GUI programming (Swing) and
with threads
• Situation:
– Sometimes Java’s design encourages us to create some
thing that might be used just once
– That thing needs to be wrapped up in a class, say because
we need a function object
• What couldn’t we just declare it at the same place
we use it? Why create a separate file?
Creating and Using an Anonymous Class
• Example: sort a list of Strings by their length
Collections.sort ( stringList, new Comparator() {
public int compare( Object o1, Object o2 ) {
return ((String) o1).length() - ((String) o2).length();
• We’ve created a new Comparator “on the fly”
– new creates a new instance, but what kind?
– Some object that implements Comparator
– Object not named, and its “true” class not named!
– What must a Comparator have? compare()
– We defined it right here, where it’s used!
Anonymous Classes: Comments
• Anonymous classes are unlike other classes
– They have no name
– Typically only implement methods in their interface or
superclass. No new methods!
– Since they have no name, can only define and use them at
one point in your code!
• Hard to understand at first? Sure!
– Naming an abstraction is important for human
– Sorting, a Collection, Comparing
• Advice
– Keep them very short (and simple)!
– Be ready to understand them when you see them in Swing
and with threads