Abstract Data Types:stepping back from
specifics
JFC/Swing lectures
Abstract Data Types (ADTs)
An ADT consists of: a set of values, and a set of operations on those values.
Example: rational numbers some values: 15/7, -3/4, 123/1, 0/1 (but NOT 1/0 !) some operations: addition, multiplication,
negation An ADT therefore specifies:
what the members are, and what operations are supported.
JFC/Swing lectures
What an ADT isn’t:
An ADT does not specify: how the data is stored/represented, or how the operations are implemented.
These details are abstracted away.An ADT is implementation independentAn ADT is language independent.In Java, an ADT is typically specified in an
interface.
JFC/Swing lectures
Data Structures (DS)
A data structure is an implementation of an ADT.
In Java, data structures are classes. In the Java Collections framework, the List
interface specifies an ADT that is implemented by several data structures: ArrayList (an array-based structure) LinkedList (a linked structure)
JFC/Swing lectures
Analogy #1: an ADT is like a vending machine
You can perform only the specific tasks that the machine's interface presents to you.
You must understand these tasks. E.g. you must know what to do to buy a beverage.
You cannot see or access the inside of the machine, because a steel shell encapsulates it.
You can use the machine even though you don't know what happens inside.
If someone replaced the machine's inner mechanism with an improved version, leaving the interface unchanged, you could still use the machine the same way.
JFC/Swing lectures
Analogy #2: an ADT is like a car
Basic interface is the same: steering wheel to determine path gearshift (on an automatic) to determine direction
(drive/reverse) pedals to determine speed (accelerator/brake)
Underlying implementation is irrelevant steering: recirculating ball, rack & pinion transmission: 3, 4 or 5 speed, CVT engine: 4, 5, 6 or 8 cylinder, gas, diesel, CNG or hybrid
Client treats them all the same!
JFC/Swing lectures
What if the interface changes?
How easy is it for people to switch from driving an automatic to a manual transmission car?
Automatic: gear selector: drive/reverse pedals: accelerator, brake
Manual: gear selector: 1, 2, 3, 4, 5, R pedals: accelerator, brake, clutch
Client needs to adjust to the new interface!
JFC/Swing lectures
With an ADT The client can only perform the operations
specific to the ADT. The client must adhere to the
specifications of the operations that the ADT provides.
Thus, client must understand how to use the operations.
JFC/Swing lectures
Interacting with a List (ADT) The client cannot access the data within the list
without using an ADT operation. The principle of encapsulation hides the data within the ADT.
The client can use the ADT, even though it can't access the data directly, and does not know how it is stored.
If you vary the implementation, but maintain the interface, the client isn’t affected and doesn’t have to care.
JFC/Swing lectures
Examples of ADTs
Bag – unordered collection, allowing duplicates Set – unordered collection, no duplicates List – ordered collection – client determines order Sorted list – comparator determines ordering Stack – Last-In First-Out (insert/remove from front) Queue – First-In First-Out (insert back, remove front) Tree – hierarchical organization Binary Search Tree – comparator determines ordering
a simple BST makes no performance guarantees more advanced BSTs can make performance guarantees
Dictionary – collection of key-value pairs Graph – collection of vertices and arcs
JFC/Swing lectures
Creating an ADTTo define an ADT, we Describe its data Specify the operations on that data Focus on “what”, not “how”.
JFC/Swing lectures
Bag ADT (revisiting details) Values: object references (unordered). We use the new Java 5 generics to define a
parameterized type. The type of the members of the ADT is
specified by a type parameter in the definition of the interface.
JFC/Swing lectures
Bag Operations (revisiting details)
Basic operations: add (client has no control over placement;
returns a boolean) remove (based on object identity; returns a
boolean) contains (membership test; returns a boolean) size (how many values are in a given bag)
Java Foundation Classes
(JFC/Swing)
Carl Alphoncerevised Spring 2007
(with contributions from Alan Hunt)
JFC/Swing lectures
Java Swing Toolkit Graphics The key to effectively using graphics in
Java is understanding: the basic components of the graphics library the patterns that are used to combine
components Must also understand how multiple
threads of execution are used to run graphical applications.
JFC/Swing lectures
Overview Patterns Containers and Components Threads
JFC/Swing lectures
Some patterns used OBSERVER STRATEGY COMPOSITE DECORATOR
JFC/Swing lectures
Some patterns used - examples OBSERVER – event handling STRATEGY – layout management COMPOSITE – containers are also components DECORATOR – scrollbars, streams
JFC/Swing lectures
java.awt.Component
All displayable objects in the graphics hierarchy extend this base class. You will never create an instance of this class directly (since it is abstract), but instead use the pre-defined GUI elements that Java provides.
JFC/Swing lectures
Containers
A container is the basic enclosing element of a graphical application. You cannot have a graphical application without a container to hold the rest of your graphical components.
The top level container for an application is usually a javax.swing.JFrame
JFC/Swing lectures
javax.swing.JFrame
A JFrame is a top-level container (meaning it does not need to be contained within any other container).
A JFrame is a window with a title and a border.
JFrames also support menu bars.
JFC/Swing lectures
An example using a JFrame(this is not "thread-safe")
public class JFrameExample {
public JFrameExample() {JFrame f = new JFrame();f.pack();f.setVisible(true);
}
public static void main(String[] args) {new JFrameExample();
}
}
JFC/Swing lectures
Composite Pattern
JFC/Swing lectures
JFC/Swing lectures
Composite Pattern The whole graphical framework is a
hierarchy of components. This is an almost textbook example of the composite pattern: a frame contains many children, which all
comply to the same interface (Component) a call to, for example, repaint() on the frame
will also call repaint() on all its children
JFC/Swing lectures
Input Elements The whole point of a Graphical User
Interface (GUI) is to accept user input and do something with it. To this end, there are a large number of input components in Swing.
Let’s first examine the JButton.
JFC/Swing lectures
Button Example
JButton button = new JButton("Push Me");
f.getContentPane().add(button);
button.addActionListener(new ActionListener(){public void actionPerformed(ActionEvent e) {
label.setText("Clicked");}
});
JFC/Swing lectures
OBSERVER PATTERN – general form
Idea: decouple event from event handling
Concrete Observable
Abstract Observable
Concrete Observer
0..*
Abstract Observable
attach(Observer)
detach(Observer)
notifyObservers()
Abstract ObservableAbstract Observer
update()
JFC/Swing lectures
JFC use of OBSERVER The observer pattern is used for event
notification. Observables (classes like JButton)
generate events. An observable can have many observers. The pattern is applied several times in
design of class library. Pattern is tailored to application: method
names are suitable for each application.
JFC/Swing lectures
OBSERVER PATTERN - applied
In JFC/Swing, Observer is realized for different event types, with methods named accordingly.
Abstract Observable
0..*
JButton
addActionListener(ActionListener)
removeActionListener(ActionListener)
fireActionPerformed(ActionEvent)
Abstract ObservableActionListener
actionPerformed(ActionEvent)
attach addActionListenerdetach removeActionListenernotifyObservers fireActionPerformed
update actionPerformed
JFC/Swing lectures
Multiple Observers
We can add more than one observer to our button. All observers are notified when a button event occurs. Let us add an observer that will also change the color of the label.
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
label.setForeground(Color.RED);
}
});
JFC/Swing lectures
DECORATOR A decorator adds functionality while
maintaining an interface. One example:
InputStreamReader wraps InputStream BufferedReader wraps InputStreamReader
Another example: JScrollPane wraps Jlist
JFC/Swing lectures
STRATEGY A layout manager has responsibility for
laying out components within a container. Unlike in NGP, JFC containers do not have
fixed layout managers. Layout managers are treated as
strategies. Strategies can be swapped.
JFC/Swing lectures
Layout Managers Swing has several different layout
managers. Some of the most common are FlowLayout, BorderLayout, GridLayout, and GridBag Layout. Each has advantages and disadvantages.
JFC/Swing lectures
BorderLayout
The BorderLayout manager creates an object that resembles a picture with a four sided frame, or border.
JFC/Swing lectures
FlowLayout FlowLayout is arguably the simplest layout
manager. It just stacks up components in a row, right to left. If it runs out of space, it wraps to a new line. This is the default layout manager for JPanel. You can see the behavior in how the button, text area, and combo box are laid out.
JFC/Swing lectures
GridLayout GridLayout arranges its components in an
equally spaced grid of cells. Will take as much space as is available to it.
JFC/Swing lectures
GridBag Layout GridBag is both the most flexible of the
layout managers, and the most difficult to use. It allows you customize the size and growth of all the components separately, but setting it up is a pain.
JFC/Swing lectures
Topic overview Processes & Threads Containers (graphical) Components Layout managers Event handling Inner classes
JFC/Swing lectures
Processes and Threads What is a process? What is a thread? two special Java threads
main thread event-dispatching thread
the Runnable interface
JFC/Swing lectures
Processes A program that is running on a computer is
called a process. most consumer OSes allow many processes to run
simultaneously a single program can give rise to many processes
bob runs Netscape – one process sally runs Netscape – another process
multitasking at the operating system level
JFC/Swing lectures
Threads Each process has its own (main) thread of
execution A process can spawn several threads
multitasking is happening at the level of the process, not at the level of the operating system
a process with multiple threads is called a multithreaded application
JFC/Swing lectures
Two Java threads Every Java program has a main thread of
execution. starts with “public static void main(String [] args)”
Graphical applications have an event-dispatching thread too.
It is important for the proper functioning of graphical, event-driven programs that graphics be run on the event-dispatching thread.
JFC/Swing lectures
Runnable interface The Runnable interface specifies one method:
public interface Runnable { /** * When an object implementing interface <code>Runnable</code> is used * to create a thread, starting the thread causes the object's * <code>run</code> method to be called in that separately executing * thread. * <p> * The general contract of the method <code>run</code> is that it may * take any action whatsoever. * * @see java.lang.Thread#run() */ public abstract void run();}
JFC/Swing lectures
How is Runnable used? An object which is Runnable has a run
method. An object which is Runnable can be run in
a specific thread. The javax.swing.SwingUtilities class
provides a method, invokeLater, which takes a Runnable, and calls its run method once other events queued on the event-dispatching thread have been handled.
JFC/Swing lectures
What does this have to do with graphics? To be “thread safe” graphical applications
should run their GUI code on the event-dispatching thread.
They do this by starting their GUI on the event-dispatching thread write the GUI creation code in a Runnable pass this object to the invokeLater method.
JFC/Swing lectures
Graphical containers All graphical elements are contained inside
some graphical container, except the so-called “top-level” containers.
Containers can contain other containers Top-level containers:
JFrame JDialog JApplet
JFC/Swing lectures
Example Creating just a frame
new javax.swing.JFrame()
Creating a frame with a title new javax.swing.JFrame(“My title”)
Making the frame visible: call setVisible(true) on the frame
Making application close when window is closed: call setDevaultCloseOperation(JFrame.EXIT_ON_CLOSE) on
the frame Go look at example_set_1
JFC/Swing lectures
Adding components Top-level containers have multiple panes Content pane is the one which holds
components call getContentPane() on frame to get frame’s
content pane call add(…) on content pane to add a
component
JFC/Swing lectures
A simple component A JLabel is a component that can display
text or an image. Go look at example_set_2
JFC/Swing lectures
Layout managers What happens if we add another JLabel?
Go look at example_set_3
JFC/Swing lectures
Another component A JButton is a component which is typically
set up to react to clicks. Clicks on buttons, mouse movements, etc.
are all considered events. A program can react to events by setting
up event handlers. Like an exception handler, an event
handler defines what should happen when a particular event occurs.
JFC/Swing lectures
Event handling – 1 The component which gives rise to an event
is decoupled from the part of the code that handles the event.
This is called the observer pattern. General form:
www.research.ibm.com/designpatterns/example.htm
JFC/Swing lectures
Event handling – 2 Observer pattern in Java
An observer is called a listener in Java Button clicks are “ActionEvents”. Handlers for ActionEvents are ActionListeners. An event-generator can have many listeners Use “addActionListener” method to register a
listener with a component
JFC/Swing lectures
Inner Classes An inner class is a class defined inside another
class. An inner class is within the scope of the
surrounding class (and therefore has access to private variables and methods defined in class).
An anonymous inner class is an inner class defined without a name (a one-off class) saw this earlier with Runnable interface implementation
Inner classes are often used to define event handlers, especially anonymous inner classes.
JFC/Swing lectures
Event handling - 3 Go look at example_set_4
JFC/Swing lectures
Putting it all together Go look at example_set_5
JFC/Swing lectures
Topic overview Swing components in (more) detail
Containers top-level containers general containers special-purpose containers
Controls Views (uneditable displays) Editors
Layout managers in (more) detail
JFC/Swing lectures
Containers Top-level containers
JApplet, JFrame, JDialog (and subclasses) They can serve as the top of a (graphical) containment
hierarchy (i.e. they don’t need to be contained within another container).
General containers panels, scroll panes, split panes and tabbed panes They provide fairly general ways of organizing
information visually. Special-purpose containers
Won’t go into these here.
JFC/Swing lectures
Controls Swing provides many controls “Separable model architecture” We’ll touch on:
check box list menu spinner your choice, time permitting
JFC/Swing lectures
Views Views are information displays that cannot
be edited. labels, progress bars, tooltips
JFC/Swing lectures
Editors Editors are information displays which
allow editing. editor pane, text pane, color chooser, file
chooser, table, etc. Can be very complex.
JFC/Swing lectures
Containers JPanel is a very generic container. JScrollPane is a container that can provide
scrollbars to shift a “viewport” to show different parts of an underlying view.
JSplitPane provides a movable partition between two parts of a pane.
JTabbedPane provides a “tabbed” environment for displaying different views.
JFC/Swing lectures
JScrollPane (see session5.scrollpane)
JFC/Swing lectures
JSplitPane (see session5.splitpane)
JFC/Swing lectures
JTabbedPane (see session5.tabbedpane) Show tooltips. Show mnemonics.
JFC/Swing lectures
Combining containers! (see session5.combined)
JFC/Swing lectures
JCheckBox (see session5.checkbox)
JFC/Swing lectures
Model-View-Controller The Model-View-Controller pattern is often
used to help architect GUI applications: the model holds data a view displays data from the model to user a controller handles user input and
communicates with the model
V
C
M
V
M
C
JFC/Swing lectures
Models and Views Use lists as an example. The model (the data provider) of a list is
separate from its View/Controller. A JList is the view-controller, which
communicates with an underlying ListModel.
JFC/Swing lectures
How do you create a model? You can implement the ListModel interface
to create a custom data model. The JList constructor allows you to pass in
an array or a vector of data elements, which it then uses to build a default ListModel automagically.