UNIT-2

Introduction to
Abstract Window
Toolkit:(AWT)
INDEX
2.1 Working with Windows and AWT :
AWT classes hierarchy
Windows Fundamentals
2.2 Working with frame windows :
creating a frame window in applet,
Canvas,
Creating windowed program
2.3 Working with graphics –
AWT Controls: Labels, TextField, Push buttons
2.4 Layout Managers:
Flow Layout,
Border Layout,
Grid Layout,
Card Layout)
2.5 GUI with Swing using :
JApplet, JLabel, JTextField, JButton, JCheckBox,
JRadioButton, JComboBox, Menus

2.6 Event Classes:

MouseEvent Class ,
ActionEvent Class,
WindowEvent Class

2.7 Event Listner Interface:

MouseListener,
ActionListener,
WindowListener
KeyListner
AWT CLASSES
 AWT means Abstract Window Toolkit.

 AWT is an object-oriented GUI framework.

 AWT classes are contained in java.awt package.

 It contains numerous classes and methods that allows you

to create and manage windows and provides machine
independent interface for applications.

 AWT is one of the largest packages.

 AWT is a library of classes which provides GUI tools to

develop GUI applications and applets.
 AWT contains classes that can be extended and
their properties can be inherited ,and also be
abstract.

 Every GUI component must be a subclass of object

class in java.lang package.

 AWT is used to build the graphical user interface

with standard windowing elements.

 GUI= Graphical User Interface

 Button
Canvas

Checkbox
Component Panel Applet
Choice
FileDialog
Container
Java.lang Dialog
List window
Objcet Frame
Scrollbar
TextArea
TextComponent
TextField

MenuBar

MenuComponent Menu
MenuItem
CheckboxMenuItem
WINDOWS FUNDAMENTAL
 A window provides a top level window on the screen ,with no
borders or menu bar.

 The Window class provides an encapsulation of a generic

window object.

 It is subclassed by Frame and Dialog to provide capabilities

needed to support application main windows and Dialog box.

 Default Layout for window is Border Layout.

 A window is top level display area exists outside the browser

or applet area you are working on.
 It has no borders, window title, or menu bar that a typical
window manager might provide.

 Frame is a subclass that adds these parts(borders , window

title)

 Window class contains a single constructor that creates a

window that has a frame window as its parent.

 The parent frame window is necessary because only objects of

the Frame class or its subclasses contain the functionality
needed to support the implementation of an independent
window application.
 Window class implements important methods that are
used by its Frame and Dialog subclasses.

 Constructor:
public Window(Frame parent)
When parent is minimized ,Window is also
minimized. So we must create Frame before we create a
Window.

For applet you can pass null parameter(because

there is no need to access Frame),this is one way to
create Dialog.
 Window class appearance method:
1. public void pack():resizes the window to preferred size
the componentist contains.

2. public void show() : displays the window,first call to this

method generates WindowEvent with Id
WINDOW_OPENED.

3. public void dispose(): releses the resources of the

window by hiding it and removing its peer.calling this
method generates WindowEvent with Id
WINDOW_CLOSED.

4. public void toFront() : brings the window to foreground

of the display.
5. public void toBack() : puts the window in back
ground of the display.

6. public void boolean isShowing() : returns true

if the window is visible on the screen.

Window class events:

WINDOW_DESTROY,
WINDOW_EXPOSE,
WINDOW_ICONIFY,
WINDOW_DEICONIFY,
WINDOW_MOVED
CONTAINER CLASS
 To use AWT components in a program, you must contain
them.

 The Container class is a subclass of the Component

class that is used to define components that have the
capability to contain other components.

 It provides methods for adding, retrieving, displaying,

counting and removing the components that it contains.

 It provides the deliverEvent() method for forwarding

events to its components.

 The Container class also provides methods for working

with layouts.
 The layout classes control the layout of components
within a container.

 A container is a type of component that provides a

rectangular area within which other components can be
organized by LayoutManager.

Container

Window Panel
 There are two basic types of container:
1) Window class : this class creates popup windows
seperate from the main program.
It has two subclasses
1) Frame(window that have a border and a menu bar)
2) Dialog (a special window used in applications to select a file)

2) Panel class :
 A container that represents a series of an existing
window.
 the applet class is a container that is a subclasss of the
panel class.
 you can place components directly on applet panel or
use additional panel objects to subdivide the applet into
smalller sections.
PANEL CLASS
 Panel is the basic building block of an applet. It provides a
container with no special features.

 The panel class is a subclass of Container class that is

used to organize GUI components within other container
objects.

 It has single constructor that takes no parameters.

 The Applet class of the java. applet package is a subclass

of the Panel class.

 The default layout for a Panel object is Flow Layout.

 A panel container is not visible when it is added to an
applet. It is to provide a way to organize components
in a window.

 By default component are added to container in left to

right and top to bottom.

Panel p=new Panel( ); //creates Panel class’s object

Label l=new Label(“ok”);
p.add( l ); //add control to panel object
add(p); //add panel object to container
CANVAS CLASS
 The canvas component is a section of a window used
primarily as a place to draw graphics or display images.

 Canvas is more similar to a container however Canvas

component can’t be used as a place to put components.

 Canvas class implements a GUI objects that supports

drawing.

 Drawing is not implemented on the canvas itself ,but on

Graphics object provided by the canvas.
 It provides single parameter constructor and
paint() method.

Canvas c=new Canvas();

c.resize(50,50);
c.setBackground(Color.red);
add(c);
FRAME CLASS
 The frame class is used to provide the main window of an
application. It may also include menu bar.

 It is a subclass of Window that supports the capabilities to

specify the icon ,cursor ,Menu bar, and title.

 It implements MenuContainer interface so it can work with

MenuBar object.

 Default layout is Border Layout.

 Frame provides basic building block for screen oriented

applications.
 Frame allows you to change the mouse cursor ,set an
icon image have menus.

 Frame is a special type of window that looks like

other high level programs in your windowing
environment.

 It adds MenuBar ,window title and windows gadgets

(resize,minimize,window menu)to the basic window
object.
 Frame class defins 14 constants that are used to
specify different types of cursors to be used with in the
frame.
public final static int DEFAULT_CURSOR
public final static int CROSSHAIR_CURSOR
public final static int TEXT_CURSOR
public final static int WAIT_CURSOR
public final static int SW_RESIZE_CURSOR
public final static int SE_RESIZE_CURSOR
public final static int NW_RESIZE_CURSOR
public final static int NE_RESIZE_CURSOR
public final static int N_RESIZE_CURSOR
public final static int S_RESIZE_CURSOR
public final static int E_RESIZE_CURSOR
public final static int W_RESIZE_CURSOR
public final static int HAND_CURSOR
public final static int MOVE_CURSOR
DIALOG CLASS
 Dialog class is a subclass of the window class that is used to
implement dialog box windows.

 A dialog box is a window that takes input from the user.

 Border layout is a default layout.

 A dialog is a popup used for user interaction, it can be modal

to prevent the user from doing anything with the application
before responding.

 This class provide handful access methods ,which are used to

get ans sets title, determine whether it is modal, and get and
set the dialog box’s resizable properties.
 Dialog class provides a special window that is
normally used for pop up messages or input from
the user.
 It should be associated with Frame that may be
modeless or modal dialog.
 Modeless :a user can interact with both the Frame
and the dialog.
 Modal:in that blocks input to the remainder of the
application ,including the Frame, until the Dialog
box is opened.
 Constructor:
1. public Dialog(Frame parent)

2. public Dialog(Frame parent , String title)

3. public Dialog(Frame parent ,String title , boolean

modal)
 Methods:

1. public String getTitle():

2. public String setTitle(String title):

3. public boolean isResizable():

4. public boolean setResizable(boolean resizable):

5. public boolean isModal():

6. public void setModal():

AWT CONTROLS
 Label
 TextFields
 TextAreas
 Buttons
 Checkboxes
 CheckboxGroup
 ChoiceList
 Scrolling lists
 Scrollbars
 Menus
 LABEL
 Labels are component that are used to display text in a
container which cant be edited by user.

 They are generally used to guide the user to perform correct

actions on the user interface ,also used for naming other
components in the container.

Label l1=new Label(“name”);

add(l1);
 Label constructor:
1)Label() :creates an empty label, with its text alilgned to left.
2)Label(String):creates label with given text, aligned left.
3)Label(String ,int) :creates a label with given text string and
given alignment value.
0 is Label. LEFT,
1 is Label. RIGHT ,
2 is Label. CENTER

Methods:

1.getText()
2.setText(String)
3.GetAlignment()
4.SetAlignment(int)
TEXTFIELDS
 TextFields is used for inserting a single line of text.
 It creates an empty text field with an unspecified number
of columns.
TextField t1=new TextField (8);
add(t);

 TextFields Constuctors:
1) TextField():creates an empty TextField is 0 character
wide.
2) TextField(int):creates empty text field.int eger
argument defines no. Of characters to display.
3) TextField(String):creates a text fields initialized with
given string.
4) TextField(String ,int):creates a text field some
number of characters wide.
 Methods  Description
1. getText()  Returns text contained in textfield
2. setText (String)  Puts the text in text fields
3. getColumns()  Returns width of this text field
4. select(int,int)  Selects text between two integer
positions
5. selectAll()  Selects all text in the field
6. isEditale()  Returns true or false based on
whether text is editable.
 True enables text to be edited, false
7. setEditable(boolea
freezes the text
n)

 Returns character used for making

8. getEchoChar()
input.
TEXTAREA (EXAPMLE)

 Creates an empty text area with an unspecified number

of rows and columns.
 The number of rows and coluns are specified as
parameters to the constructor
 It provides the capability to set the text to read-only or
edit mode.
TextArea t=new TextArea(5,20);
Add(t);

 TextArea constructor:
1. TextArea():creates an empty text area 0 rows long
and 0 characters wide.
2. TextArea(int,int):creates an empty text area with
given number of rows and columns
3. TextArea (String):creates a text area displaying the
given string.
4. TextArea(String,int,int):creates a text area displaying
the given string and with given dimensions

TextArea t=new TextArea(“hi \n hello”,7,25);

Methods:
1. getColumns()

2. getRows()

3. insertText(String,int):inserts the string at the given

position in the text
4. replaceText(String,int,int):replaces the text between
the given integer positions with the new string
BUTTONS
 Button component is used to trigger enents in GUI.
 It is rectunglar button thta can be clicked with a mouse.
 Buttons are easy to manage and make the interface
presentable.
 Button constructor:
1. Button()
2. Button(String)

We can add button in panel using following code:

Panel p=new Panel ();

Button b=new Button(“ok”);
p.add(b);
 Methods
 String getLabel() : read label from button
 void setLabel( String s) :set Label on button
 An action event is generated each time a button is pressed.
 The methods are used by which other objects register and
unregister to receive action events generated by this
component.

1. void addActionListener(ActionListener al)

2. void removeActionListener(ActionListener al)
 An action listener may use the getActionCommand( )
method to obtain a string associated with an action event
generated with an action event generated by button.
String getActionCommand( )
// return value is action command.
 java.awt.event.ActionListener interface defines one method
that must be implemented by action listener.
void actionPerformed( ActionEvent ae)

 Steps to use button in applet:

1. Create a Button object.
2. Register the applet to receive action events generated by
the button.
3. Invoke the add( ) method to add the Button object to
applet.
4. Implement the ActionListener interface in applet.
CHECKBOXES
 A check box is a used to control in an application or a web
page.
 A check box has two parts ,a label and a state(small box)
 The label text is text that represents the caption of the
control
 The state is a boolean value that represents the status of
check boxes whether checked or unchecked .
 By default the state is false ,means checkbox is unchecked.

Syntax:
Checkbox ch1=new Checkbox("pen");
add(ch1);
Methods:
getLabel() setLabel(String) getItem( )
getState() setState(boolean) getItemSelectable( )
getstateChange( )

Constructor :
 Checkbox ( )

 Checkbox(String s,boolean state)

 Checkbox(String s,boolean state,CheckboxGroup grp)

 Checkbox(String s, CheckboxGroup grp,boolean state)

Another methods
 void addItemListener(ItemListener il)

 void removeItemListener(ItemListener il)

CHECKBOXGROUP (RADIOBUTTONS)
 CheckboxGroup class is used with the Checkbox class
to implement radio buttons.
 All Checkbox objects associated with CheckboxGroup
object are treated as a single set of radio buttons.
 Only one button in group may be set or on at a given point
in time.

 We can get and set CheckboxGroup object.

CheckboxGroup cbg=new CheckboxGroup ( );

Checkbox ch1=new Checkbox("male");
ch1.setCheckboxGroup(cbg);
ch1.setState(false);
add(ch1);
 Checkbox getSelectedCheckbox( )
 void setSelectedCheckbox (Checkbox cb)
CHOICE LIST
 Choice class is used to implement pull-down lists that can
be placed in the main area of a window.

 This list are known as option menus or a pop-up menu

of choices.

 It is a pop up list of strings from which a single string can

be selected. It enables selection of one Item at a time.

Choice c=new Choice();

c.addItem(“bhuj”);
c.addItem(“rajkot”);
c.addItem(“surat”);
add(c);
Methods:
 add(String s)
 addItem(String s)
 getItem(int)
 countItems()
 getIndex(int t)
 select(int)
 getSelectedItem()
 Select(string)
 remove( )
SCROLLING LISTS OR LIST BOX
 A list box is simmilar control to a choice list ,however
unlike choice menu ,a list control allows the user to select
multiple values inthe list as the same time.

 One or more string can be selected at same time.

 List constructor:
1) List() :

2) List(int, boolean):integer argument defines no. Of

element to be displayed on screen and boolean specifies
whether list enables multiple choice or not.
3) List(int i)
Methods:
 getItem()
 getSelectedIndex()
 countItems()
 getSelectedIndexes()
 select()
 getSelectedItem()
 setectAll()
 getSelectedItems()
SCROLLBAR
 Scrollbar is used to implement vertical and
horizontal scrollbars.
 scrollbar component is up-down or left-right
slider that can be used to set a numeric value.
 You can use scrollbar by clicking mouse or an
arrow or by grabbing the box on the slider.
 Scrollbar constructor:
1. scrollbar():creates scrollbar with its intial maximum and
minimum value 0,in vertical .

2. scrollbar(int):creates scrollbar with its intial maximum

and minimum value 0,the argument can be set to
scrollbar.HORIZONTAL or scrollbar.VERTICAL.

3. Scrollbar(int ,int ,int ,int ,int ):

overall width
scrollbar.HORIZONTAL of scrollbox
Or initail value minimum & maximum
scrollbar.VERTICAL. of scrollbar values for scrollbar
 getMaximum()
 getMinimum()

 getOrientation() :

0 for Horizontal
1 for vertical
 getValue()

 setValue()

 setLineIncrement()

 setLineIncrement()

 setPageIncrement(int c): default is 10

 setPageIncrement()
MENUS
 A menu is component of AWT but it is different from other
components because it can’t be added to ordinary container and
laid out by layout manager.
 Menu can be added only to a menu container.toplevel window can
have menubar which display list of top level menu choices and
each choice is associated with a dropdown menu.

Object

Menu Component
type title her

Manubar MenuItem

CheckboxMenuItem Menu

PopupMenu
 A MenuBar component is a horizontal menu in which
contains on more Menu objects.
 It can only be added to Frame object.
 It forms the root of all menu trees.
 A Frame can display only one MenuBar at a time.
 The Menu Bar does not support any listener.

 MenuBar Constructor:
 - MenuBar ( ): to create default MenuBar.
 Menu:
 A menu component provides a basic pull down menu.
 It can be added either to a menu bar or to another
Menu.
 Menus are used to display and control Menu items.

 Menu Constructor:
 Menu () : to create default menu.
 Menu (String str): str specifies name of the menu
selection
 Menu(String str, Boolean flag):flag shows popup
menu if set true it can be removed and allowed to
float free.
 MenuItem
 MenuItem component are text leaf nodes of a menu
tree.
 MenuItem are added to a Menu.

 An actionListener can be added to a MenuItem Object.

 MenuItem constructor:
 MenuItem () :create s a default constructor

 MenuItem (String str) : str is the name shown in the

menu.
 MenuItem (String str,MenuShortcut key ):key is
shortcut key for that MenuItem.
 CheckboxMenuItem
 It is checkable menu item, which provides
selection (on or off) listed in menus.
 It can be controlled by the ItemListener
interface.

 CheckboxMenuItem constructor:
 CheckboxMenuItem() :

 CheckboxMenuItem(String str):

 CheckboxMenuItem(String str, boolean flag):

LAYOUT MANAGERS
 There's no guarantee that a textbox or any component
will be the same size on each platform.

 Sun Microsystems has created a LayoutManager

interface that defines methods to reformat the screen
based on the current layout and component sizes.

 Layout manager try to give a consistent and

reasonable appearance regardless of platform ,the
screen size, or actions the user might take.

 It determines that how AWT components are

dynamically arranged on the screen.
 Layout manager is an object that is used to organize
components in container.

 Every container has default layout manager.

 As soon as you create container java automatically

creates and assigns layout manager to it.

BorderLayout
CardLayout

FlowLayout
Java.lang
GridBagLAyout
Objcet
GridBagConstarints

GridLayout
FLOW LAYOUT
 It is default layout for applets and Panels.

 It places controls in the order in which they are added

,linearly, from left to right and from top to bottom in
horizontal and vertical rows.

 We can align components to left, right or center.

 Components are normally centered in applet.

 When the layout manager reaches the right border of the

container(means row is full then), it positions the
components in the next row.
 If you resize an applet ,the components flow will change
based upon the new width and height.

To create flow Layout :

FlowLayout f1=new FlowLayout();

FlowLayout f2=new FlowLayout(FlowLayout.LEFT);
FlowLayout f3=newFlowLayout(FlowLayout.LEFT,10,30);

setLayout(f1)
 Buttons and Flow Layout
width=400 height=50

width=100 height=120
GRID LAYOUT
 The Grid layout class puts each component into a place on a
grid that is equal in size to all the other places.
#1 #2
#3 #4
#5 #6

 The grid is given specific dimensions when created;

Components are added to the grid in order ,starting
with upper-left corner to right.

 Components are given equal amounts of space in the

container.

 Gridlayout is widely used for arranging components in rows

and columns.
 However unlike, FlowLayout ,here underlying
components are resized to fill the row-column area. If
possible.

 Gridlayout can reposition objects after adding or

removing components. Whenever area is resized,
components are also resized.

GridLayout b1=new GridLayout(4,1);

setLayout(b1)
row=3 col=2 row=0 col=1

row=1 col=0
BORDER LAYOUT
 Border layout is the default layout manager for all window,
dialog and frame class.
 In Border layout ,components are added to the edges of the
container ,the center area is allotted all the space that’s left
over.
North

east
west
center

south

 Border layout ,provides five areas to hold component:

Four border North,south,east,west
Remaining space: center
 When you add a component to the layout you must
specify which area to place it in.
 The order in which components are added to the
screen is not important. Although you have only
one component in each area.

BorderLayout b1=new BorderLayout();

setLayout(b1);

add(bt1,BorderLayout.NORTH);
add(bt2,BorderLayout.SOUTH);
CARD LAYOUT
 Card layout class is a special type of layout organizer.

 A cardlayout manages several components ,displaying

one of them at a time and hiding the rest.

 All the component are given same size, Usually

CardLayout manages a group of panels and each panel
contains several component of its own.

 It doesn’t display several panels concurrently but it

creates a stack of panels that can then be displayed one
at a time, as stack of cards in solitaire game.
 CardLayout allows you to assign names to the
components it is managing and lets you jump to a
component byname.

 CardLayout class has its own method that are used to

control which panel is displayed. Clicking on applet
area causes the Layout manager to laos the next
panel.
GRIDBAG LAYOUT
 GridBagLayout class provides a grid for components like
GridLayout ,but allows a single component element to occupy
multiple cells of the grid.

 Each GridBagLayout uses a rectangular grid of cells,just like

a GridLayout.

 Cells are determined and shaped by the component placed in

them rather than components being shaped to fir the cells.

 Cells in grid are not required to take up same amount if space

,and components can be aligned in different ways in each grid
cell.
 GridBagLayout constructor is trivial ,with no arguments.
GridBagLayout gb=new GridBagLayout();

 Unlike GridLayout() constructor ,this constructor does

not specify the number of rows or columns.

 Rows and columns are added as required(starts

from 0.)

 You will need access to the GridBagLayout object later

in the applet when you add components to the container.
 GridBagConstraints objects
- GridBagConstraints object specifies the location and area
of the components display area with in the container ,and
how they are laid out inside its display area.
 GridBagConstraints gbc=new GridBagConstraints();

- GridBagConstraints varaible are:

1) gridx and gridy: these variable specifies cell in the grid

where the component should be placed.gridx represents
rows and gridy represents columns.

2) gridheight and gridwidth: the no. Of cells a component

should occupy gridheight means no.of rows gridwidth
means no. Of columns.

3) fill: it specifys the directions in which a component should

expand if it has room to grow inside its cells.(in
HORIZONTAL , VERTICAL ,BOTH)

4) anchor: a way in which component should be aligned in cell.

 GUI WITH SWING
 Swing is a set of classes that provide more powerful and
flexible components than AWT.

 Swing provides familiar components like buttons,

checkbox and label and also adds new components like
tabbed pane, scroll panes, tree and tables.

 In swing button may have both an image and a text

string associated with it. the image can be changed as
the state of the button changes.

 The swing related classes are contained in javax.swing

and its sub packages
 Object

Component

Container

JComponent

AbstractButton JSlider JLabel JMenuBar JComboBox JScrollBar

JButton JToggleButton JTextComponent

JCheckBox JRadioButton JTextField JTextArea

APPLET AND SWING
Applet Swing
 AWT stands for Abstract  Swing is also called as JFC’s
windows toolkit. (Java Foundation classes).
 AWT components are called  Swings are called light weight
Heavyweight component. component because swing
components sits on the top of
AWT components and do the
work.
 Swing components require
 AWT components require javax.swing package.
java.awt package.
 Swing components are made in
 AWT components are purely java and they are
platform dependent. platform independent.
 This feature is not  We can have different look and
supported in AWT. feel in Swing.
 This feature is not  Swing components are called
available in AWT. "lightweight" because they do
not require a native OS object
to implement their
functionality components
 With Swing, you would have
 With AWT, you have 21 only one peer, the operating
"peers" (one for each system's window object.
control and one for the
dialog itself).

 Swing is much larger. Swing

 AWT is a thin layer of code
also has very much richer
on top of the OS.
functionality.
 Using AWT, you have to
 Swing has them built in.
implement a lot of things
yourself.
The swing component classes are as follow:
 JApplet

 JLabel

 JTextField

 JButton

 JCheckBox

 JRadioButton

 JComboBox

 JtabbedPane (Menus)
1. JApplet :
 Fundamental of Swing is JApplet class, which extends
Applet.
 Applets that uses Swing must be subclasses of JApplet.
 JApplet is rich with functionality .It supports various
“panes”,such as content pane, glass pane and root pane.
 When adding a component to an instance of JApplet,do not
invoke the add( ) method of the applet. But call add( )for
content pane of the JApplet object.
 We can obtain content pane using getContentPane( )
method.
 The add( ) method of container can be used to add a
component to content pane.
void add (component comp)
//component which you want to add
2. JLabel:
 Swing labels are instances of JLabel class. which extends
JComponent.
 It can display text and/or icon.

 Constructor of JLabel
 JLabel( Icon i)
 JLabel(String s)
 JLabel (String s , Icon I , int align)
//Align is either
LEFT,RIGHT,CENTER,LEADING or TRAILING.
 Methods of JLabel:
 Icon getIcon( )
 String getText( )
 void setIcon( )
 void setText( )
// Swing application Program using JFrame
import java.awt.*;
import javax.swing.*;
public class JLabelDemo extends JFrame
{
JLabel lb;
JLabelDemo()
{
super("JLabel Demo");
lb = new JLabel("Welcome TO ADVANCE JAVA");
add(lb);
setVisible(true);
setSize(300,300);
}
public static void main(String args[])
{ new JLabelDemo(); }
}
// applet Program using JApplet
import java.awt.*;
import javax.swing.*;
/*<applet code="JLabelDemo.class" width=400 height=500>
</applet>*/
public class JLabelDemo extends JApplet
{
JLabel jlb1=new JLabel("welcome........");

public void init()

{
JPanel jp=new JPanel();
jp.add(jlb1);
add(jp);
}
}
// Swing program using Conatainer
import java.awt.*;
import javax.swing.*;
/*<applet code="JLabelDemo.class" width=400
height=500></applet>*/
public class JLabelDemo extends JApplet
{
JLabel jlb1=new JLabel("ok----",JLabel.CENTER);
public void init()
{
Container cp=getContentPane();
cp.add(jlb1);
}
}
ICON
 To get the icon/image the method is :
ImageIcon img=new ImageIcon(String img);
 we can set the actionCommand using
setActionCommand() method.
3. JTextField:
 Swing text field is encapsulated by JTextComponent class,
which extends JComponent class.

 It provides functionality that is common to Swing text

Components. One of its sub class is JTextField, which allows
you to edit one line of text.

 Constructor
 JTextField( )
 JTextField(int cols)
 JTextField(String s,int cols)
 JTextField(String s)
 Swing buttons provide features that are not found in the
Button class defined by the AWT.
 Swing buttons are subclasses of AbstractButton class which
extends JComponent.
 AbstractButton is a super class for push buttons, checkboxes
and radio buttons. It contains many methods that allow you
to control the behaviour of buttons, checkboxes and radio
buttons.
void setDisabledIcon(Icon)
void setPressedIcon (Icon)
void setSelectedIcon (Icon)
void setRolloverIcon(Icon)
 Concrete subclasses of AbstractButton generate action
events when they are pressed. Method used for even
handling are,
 void addActionListener( ActionListener l)
 void removeActionListener(ActionListener al)
JButton:
 Methods for Button
1. getText( )
2. setText(String s)

 JButton class provides the functionality of a push

button. JButton allows an icon, a string or both to be
associated with the push button.
 Constructor for JButton :

1. JButton(Icon i)
2. JButton(String s)
3. JButton(String s,Icon i) //s and i are the string
and icon used for the button.
 JCHECKBOX
 JCheckBox class which provides the functionality of a check
box, is a subclass of AbstractButton class. Its immediate super
class is JToggleButton.
 It supports two states true or false. We can associate an icon,
string, or the state with the checkbox.
 JCheckBox constructors:

1. JCheckBox(Icon c)
2. JCheckBox(Icon c,boolean state)
3. JCheckBox(String s)
4. JCheckBox (String s,boolean state)
5. JCheckBox (String s,Icon i)
6. JCheckBox (String s,Icon c,boolean state)
 Here, i is the icon for the button.s is text to be displayed.

 If state is true,the checkbox is initially selected else not.

 The state of the check box can be changed via following
method:
void setSelected(boolean state)

 When a check box is selected or deselected ,an item event is

generated. This is handled by itemStateChanged( ).

 The getItem( ) method is used to get JCheckBox object that

generated the event.

 The getText( ) method gets the text for that check box and
text inside the text field.

 To select only one you have to create a object of

ButtonGroup class and add all components in the object.
JRadioButton
 Radio buttons are supported by the JRadioButton class,
which is a concrete implementations of
AbstractButton.JRadioButton’s immediate super class is
JToggleButton, which provides support for two state
buttons.

 Radio buttons must be configured into a group. Only one of

the buttons in that group can be selected at any time.

 The ButtonGroup class is instantiated to create a button

group. Its default constructor is invoked for this purpose.
Elements are then added to the button group via add( )
method.
void add(AbstractButton ab) //ab is reference to
the button to be added to group.
Constructor for JRadioButton
 JRadioButton (Icon c)

 JRadioButton (Icon c,boolean state)

 JRadioButton (String s)

 JRadioButton (String s,boolean state)

 JRadioButton (String s,Icon i)

 JRadioButton (String s,Icon c,boolean state)

JComboBox
 Swing provides a combo box(a combination of a text field
and a drop down list) through the JComboBox class,
which extends JComponent.
 A combo box normally displays one entry. However, it can
also display a drop-down list that allows a user to select a
different entry.
 You can also type your selection into the text field.

 Constructor of JComboBox

 JComboBox( )
 JComboBox(Vector v) //v is vector that initializes the
combo box.
 Items are added to the list of choices via
addItem()method,
void addItem( Object obj) //obj is object to be added to
the combo box
 JTabbedPane
 A tabbed pane is a component that appears as a group of
folders in a file cabinet. Each folder has a title. When a user
selects a folder, its content becomes visible. Only one of the
folders may be selected at a time.
 Tabbed panes are commonly used for setting configuration
options.
 Tabbed panes are encapsulated by the JTabbedPane class,
extends JComponent.
 We will use its default constructor. Tabs are defined via the
following method.
void addTab(String str, Component comp)
str is title for the tab
comp is the component that should added to the tab.
 Typically, a JPanel or a subclass of it is added.
 The general procedure to use a tabbed pane in an applet
is outlined here.

1. Create a JtabbedPane object.

2. Call addTab ( ) to add a tab to the pane.(The arguments
to this method define the title of the tab and the
component it contains.
3. repeat step 2 for each tab.
4. Add the tabbed pane to the content pane of the applet.
 JMenu
 We can create a Menu Bar which contains several menus.

 Each menu can have several menu items. The separator

can also be used to separate out these menus.

 JMenuBar :- This class creates a menu bar.

 Jmenu (String s) :- This class creates several menus. The
string s denotes the name of the menus.
 JMenuItem ( String s) :- The menu items are the parts of
menus. The string s denotes the name of the menu item.
 setMnemonic(char c) :- The character which is passed to it as
an argument becomes the mnemonic key. Hence using alt+c you
can select that particular menu.
 JSeparator :- This is the constructor of the class
JSeparator which adds separating line between
the menu items.
 setMenuBar :- This method is used to set menu
bar to a specific frame.
EVENT HANDLING
The delegation event model
 The modern approach to handling event is based on
delegation event model, which defines standard and
consistent mechanism to generate and process events.

 It provides simple concept.

 A source generates an event and sends it to one or more
listeners.
 In this, the listener simply waits until it receives an
event.
 Once received, the listener processes the event and then
returns.
 Advantage: application logic that processes events is cleanly
separate from the user interface logic that generates those
events. A user interface element is able to “delegate” the
processing of an event to a separate piece of code.

 In delegation event model, listeners must register with a

source in order to receive an event notification. Because
notifications are sent only to that listeners which wants to
receive them.

 In old version of java (1.0),event was circulated up the control

hierarchy until it was handled by a component. This required
components to receive event that they did not process, and it
wasted valuable time. The delegation event model eliminates
this overhead
EVENTS
 When the user interacts with a GUI application, an event
is generated.
 Events are represented as Objects in Java.
 Changing the state of an object is known as an
event.
 Example: user events are clicking a button, selecting an
item or closing a window. Events may also occur that are
not directly caused by interaction with a user interface. An
event may be generated when a timer expires, a counter
exceeds a value, a software or hardware fails.
 The java.awt.event package provides many event classes
and Listener interfaces for event handling.
 The super class of all event classes is
java.util.EventObject. Some of the important classes
and their hierarchy are shown below.
 EVENT SOURCES
 A source is an object that generates an event. This
occurs when the internal state of that object changes in some
way. Source may generate more than one type of event.
 A source must register listeners for the listeners to receive
notifications about a specific type of event. Each type of event
has its own registration method.
public void addTypeListener (TypeListener el) //Type
is the name of the event and el is a reference to the event
listener.
 When an event occurs, all registered listeners are notified and
receive a copy of event object. This is known as multi
casting. In all cases notifications are sent only to listeners
that register to receive them.
 A source must also provide a method that allows a listener to
unregister an interest in specific type of event.
public void removeTypeListener(TypeListener el)
EVENT LISTENERS

 A listener is an object that is notified when an event

occurs. It has two major requirements

1) It must have been registered with one or more sources to

receive notifications about specific types of events.
2) It must implement method to receive and process these
notifications.

 The methods that receives and process events are defined in

a set of interfaces found in java.awt.event.
 EVENT CLASSES
 Event classes represent the events. At root of Java event class
hierarchy is EventObject, which is in java.util package.
 EventObject (Object src) //src is the object that generates
event.

 EventObject Contains 2 methods:

1) Object getSource ( ): returns the source of the event.
2) String toString ( ): returns the string equivalent of the event.

 AWTEvent class defined in java.awt package is a subclass of

EventObject. It is super class (directly or indirectly) of all AWT-
based events handled by delegation model.
 Its getID ( ) method can be used to determine the type of event.
 Class Description
It is the root event class for all AWT
events. This class and its subclasses
1 AWTEvent
supersede the original java.awt.Event
class.
The ActionEvent is generated when
2 ActionEvent button is clicked or the item of a list is
double clicked.
The InputEvent class is root event class
3 InputEvent for all component-level input events.
On entering the character the Key event
4 KeyEvent
is generated
This event indicates a mouse action
5 MouseEvent
occurred in a component.
The object of this class represents the text
6 TextEvent
events
 The object of this class represents
7 WindowEvent the change in state of a window.

The object of this class represents

8 AdjustmentEvent the adjustment event emitted by
Adjustable objects.
The object of this class represents
when component is
9 ComponentEvent
hidden,moved,resized or becomes
visible
The object of this class represents
10 ContainerEvent when component is added or
removed from container
When mouse motion occurs ,mouse
11 MouseMotionEvent moved or dragged

The object of this class represents

12 PaintEvent when paint is invoked
ACTIONEVENT CLASS
 ActionEvent is generated when button is pressed, a list
item is double clicked, menu item is selected or when press
Enter key in a text box.

 This class is defined in java.awt.event package.

 ActionEvent class defines four integer constant that can
be used to identify any modifiers associated with an action
event.
 static int ALT_MASK -- The alt modifier.
 static int CTRL_MASK -- The control modifier.
 static int META_MASK -- The meta modifier.
 static int SHIFT_MASK -- The shift modifier.
 static int ACTION_PERFORMED -- This event id
indicates that a meaningful action occurred
Class declaration
 Following is the declaration for java.awt.event. ActionEvent
class:
public class ActionEvent extends AWTEvent

Class constructors
 ActionEvent (Object src, int id, String cmd): Constructs an
ActionEvent object.
 ActionEvent (Object source, int id, String cmd, int
modifiers): Constructs an ActionEvent object with modifier
keys.
 ActionEvent (Object source, int id, String cmd,long when,
int modifiers): Constructs an ActionEvent object with the
specified modifier keys and timestamp.
 Class methods :
 String getActionCommand ( ): Returns the command
string associated with this action. For example, when a
button is pressed, an action event is generated that has
a command name equal to the label on that button.

 int getModifiers ( ) :Returns a value that

indicates which modifier keys (ALT,CTRK,META
and/or SHIFT) were pressed when event was
generated.

 long getWhen( ) :Returns the time at which the

event occurred

 String paramString( ):Returns a parameter string

identifying this action event.
MOUSEEVENT CLASS
 KeyEvent and MouseEvent are subclasses of abstract
InputEvent class. Both these events are generated by
objects of type Component class and its subclasses.
 The KeyEvent is generated when the user presses or
releases a key on the keyboard.
 The MouseEvent is generated when the user presses the
mouse or moves the mouse. This event indicates a mouse
action occurred in a component.
 This low-level event is generated by a component
object for Mouse Events and Mouse motion events.
 a mouse button is pressed
 a mouse button is released
 a mouse button is clicked (pressed and released)
 a mouse cursor enters the unobscured(uncertain) part of
component's geometry
 a mouse cursor exits the unobscured part of component's
geometry
 a mouse is moved
 the mouse is dragged
 Class declaration
 Following is the declaration for
java.awt.event.MouseEvent class:
 public class MouseEvent extends InputEvent

Fields
Following are the fields for java.awt.event.MouseEvent class:

 static int BUTTON1 --Indicates mouse button #1; used by

getButton()
 static int BUTTON2 --Indicates mouse button #2; used by
getButton()
 static int BUTTON3 --Indicates mouse button #3; used by
getButton()
 static int NOBUTTON --Indicates no mouse buttons; used
by getButton()
There are eight types of mouse events:
 static int MOUSE_CLICKED --The "mouse clicked" event

 static int MOUSE_DRAGGED --The "mouse dragged" event

 static int MOUSE_ENTERED --The "mouse entered" event

 static int MOUSE_EXITED --The "mouse exited" event

 static int MOUSE_MOVED --The "mouse moved" event

 static int MOUSE_PRESSED -- The "mouse pressed" event

 static int MOUSE_RELEASED --The "mouse released" event

 static int MOUSE_WHEEL --The "mouse wheel" event

 static int VK_WINDOWS --Constant for the Microsoft

Windows "Windows" key.
 Class constructor

MouseEvent (Component src, int id, long when,

int modifiers, int x, int y, int clickCount,
boolean popupTrigger ):
 Constructs a MouseEvent object with the specified source
component, type, modifiers, coordinates, and click count.
 MouseEvent class methods

 int getButton ( ): Returns the value that represents the

button that caused the event.
 int getClickCount( ) :Returns the number of mouse clicks
for this event.
 Point getPoint() :Returns the x,y position of the event
relative to the source component.
 int getX() :Returns the horizontal x position of the event
relative to the source component.
 int getXOnScreen() Returns the absolute horizontal x
position of the event.
 int getY() returns the vertical y position of the event
relative to the source component.
 int getYOnScreen() :Returns the absolute vertical y
position of the event.
 void translatePoint(int x, int y) Translates the event's
coordinates to a new position by adding specified x
(horizontal) and y (vertical) offsets.
 Point getLocationOnScreen (): Returns the absolute x, y
position of the event.
 static String getMouseModifiersText(int modifiers)
:Returns a String describing the modifier keys and mouse
buttons that were down during the event, such as "Shift", or
"Ctrl+Shift".
 boolean isPopupTrigger() Returns whether or not this
mouse event is the popup menu trigger event for the
platform.
 String paramString() Returns a parameter string
identifying this event.
WINDOWEVENT CLASS:
 WindowEvent are generated for the Window class and its
subclasses. The object of this class represents the change in
state of a window. These events are generated if an operation
is performed on a window.
 The operation could be closing of window, opening of window,
activating a window etc.
 This low-level event is generated by a Window object when it
is opened, closed, activated, deactivated, iconified, or
deiconified, or when focus is transferred into or out of the
Window.

 Class declaration
Following is the declaration for java.awt.event.WindowEvent
class:
public class WindowEvent extends ComponentEvent
 There are ten types of window events:
 static int WINDOW_ACTIVATED --The window-activated
event type.
 static int WINDOW_CLOSED -- The window closed event.

 static int WINDOW_CLOSING -- The "window is closing"

event.
 static int WINDOW_DEACTIVATED -- The window-
deactivated event type.
 static int WINDOW_DEICONIFIED -- The window deiconified
event type.
 static int WINDOW_GAINED_FOCUS -- The window-gained-
focus event type.
 static int WINDOW_ICONIFIED -- The window iconified event.

 static int WINDOW_LOST_FOCUS -- The window-lost-focus

event type.
 static int WINDOW_OPENED -- The window opened event.

 static int WINDOW_STATE_CHANGED -- The window-state-

changed event type.
 Class constructors
 WindowEvent(Window source, int id) : Constructs a
WindowEvent object.

 WindowEvent(Window source, int id, int oldState, int

newState) :Constructs a WindowEvent object with the
specified previous and new window states.

 WindowEvent(Window source, int id, Window opposite)

:Constructs a WindowEvent object with the specified
opposite Window.

 WindowEvent(Window source, int id, Window opposite,

int oldState, int newState) :Constructs a WindowEvent
object.
 Class methods
 int getNewState() :For WINDOW_STATE_CHANGED
events returns the new state of the window.
 int getOldState() :For WINDOW_STATE_CHANGED
events returns the previous state of the window.
 Window getOppositeWindow() :Returns the other
Window involved in this focus or activation change.
 Window getWindow() :Returns the originator of the
event.
 String paramString() :Returns a parameter string
identifying this event.
 AdjustmentEvent is generated when the user adjusts the
position of a scrollbar. Scrollbar is the only GUI control that
receives the AdjustmentEvent.
 ItemEvent is generated when an item is selected or
deselected.
Checkbox : When the state of the Checkbox is changed.
CheckBoxMenuItem : When the state of a MenuItem is
changed.
Choice : When the state of a ChoiceBox is changed.
List : When an item in list is selected or deselected.
 TextEvent is generated when the contents of text
component are changed. The components that generate
TextEvent are TextArea and TextField.
 FocusEvent: This event is generated when a component
gains or losses focus. Focus may be gained by bringing the
mouse over a component (or by using the tab key). The
component that has the focus receives all user keyboard
events. Focus events are generated by objects of Component
class and all its subclasses.
 PaintEvent is generated when a component needs to be
repainted (for example when an application which is in front
is closed and the component needs to be redrawn.)
PaintEvent are internally handled by AWT, and cannot (and
should not) be handled by you in the application.

 ComponentEvent are also generated by objects of type

Component class and its subclasses. This event is generated
when a component is hidden, shown, moved or resized.

 ContainerEvent are generated when a component is added

or removed from a container. ComponentEvent and
ContainerEvent are handled by AWT and are not normally
handled by the user.
 KeyEvent is subclasses of abstract InputEvent class. Both
these events are generated by objects of type Component
class and its subclasses. The KeyEvent is generated when the
user presses or releases a key on the keyboard.
EVENT LISTENERS
 The delegation event model has two parts: source and
listener
 Listeners are created by implementing one or more of the
interfaces defined by java.awt.event.
 When an event occurs, the event source invokes the
appropriate method defined by the listener and provides an
event object as its argument.
 The Event listener represents the interfaces responsible to
handle events.
 Every method of an event listener method has a single
argument as an object which is subclass of EventObject
class.
No. Class Description
1 ActionListener This interface is used for receiving the action events.
This interface is used for receiving the component
2 ComponentListener
events.
3 ItemListener This interface is used for receiving the item events
4 KeyListener This interface is used for receiving the key events.
5 MouseListener This interface is used for receiving the mouse events
6 TextListener This interface is used for receiving the text events.
7 WindowListener This interface is used for receiving the window events.
This interface is used for receiving the adjustment
8 AdjustmentListener
events.
This interface is used for receiving the container
10 ContainerListener
events
MouseMotionListen This interface is used for receiving the mouse motion
11
er events.
12 FocusListener This interface is used for receiving the focus events.
WindowFocusListe It is used for receiving event when a window gains or
13
ner losses input focus
1. ACTIONLISTENER INTERFACE
 The class which processes the ActionEvent should
implement this interface.
 The object of that class must be registered with a component.
The object can be registered using the addActionListener ()
method.
 When the action event occurs, that object's
actionPerformed ( ) method is invoked.

Interface declaration of java.awt.Event. ActionListener

public interface ActionListener extends EventListener

 Interface methods:
void actionPerformed (ActionEvent e) //
Invoked when an action event occurs.
2. MOUSELISTENER INTERFACE:
 The class which processes the MouseEvent should
implement this interface.
 The object of that class must be registered with a
component. The object can be registered using the
addMouseListener () method.
 Interface declaration of java.awt.Event.
MouseListener interface:

public interface MouseListener extends EventListener

Methods:
 void mouseClicked (MouseEvent e) :Invoked when the
mouse button has been clicked (pressed and released) on a
component.

 void mouseEntered(MouseEvent e) :Invoked when the

mouse enters a component

 void mouseExited(MouseEvent e) :Invoked when the mouse

exits a component.

 void mousePressed(MouseEvent e) :Invoked when a mouse

button has been pressed on a component.

 void mouseReleased(MouseEvent e):Invoked when a mouse

button has been released on a component.
WINDOW LISTENER
 The class which processes the WindowEvent should
implement this interface.
 The objects of that class must be registered with a
component. The object can be registered using the
addWindowListener ( ) method.
Interface declaration
 Following is the declaration for java.awt.Event.
WindowListener interface:

public interface WindowListener extends EventListener

 Interface methods
 void windowActivated (WindowEvent e) :Invoked when the
Window is set to be the active Window.
 void windowClosed(WindowEvent e) :Invoked when a
window has been closed as the result of calling dispose on the
window.
 void windowClosing(WindowEvent e) :Invoked when the
user attempts to close the window from the window's system
menu.
 void windowDeactivated(WindowEvent e) :Invoked when a
Window is no longer the active Window.
 void windowDeiconified(WindowEvent e) :Invoked when a
window is changed from a minimized to a normal state.
 void windowIconified(WindowEvent e) :Invoked when a
window is changed from a normal to a minimized state.
 void windowOpened(WindowEvent e) :Invoked the first
time a window is made visible.
KEYLISTENER INTERFACE:
 The class which processes the KeyEvent should implement
this interface.
 The object of that class must be registered with a component.
The object can be registered using the addKeyListener ( )
method.
 Interface declaration of java.awt.Event.KeyListener
interface:
public interface KeyListener extends EventListener

Interface methods
void keyPressed(KeyEvent e):Invoked when a key has been
pressed.
void keyReleased(KeyEvent e):Invoked when a key has been
released.
void keyTyped(KeyEvent e) :Invoked when a key has been
typed.
EVENT TYPES AND CORRESPONDING EVENT SOURCE &
EVENTLISTENER
Event Type Event Source Event Listener interface
ActionEvent Button, List, MenuItem, ActionListener
TextField
AdjustmentEvent Scrollbar AdjustmentListener
ItemEvent Choice, Checkbox, ItemListener
CheckboxMenuItem, List
TextEvent TextArea, TextField TextListener
ComponentEvent Component ComponentListener
ContainerEvent Container ContainerListener
FocusEvent Component FocusListener
KeyEvent Component KeyListener
MouseEvent Component MouseListener,
MouseMotionListener
WindowEvent Window WindowListener
 ADAPTER CLASSES
 Event adapters facilitate implementing listener interfaces.
 Many event listener interfaces have more than one event
listener methods. For such interfaces, Java technology defines
adapter classes.
 These have empty implementation (stubs) of all the event
listener methods defined in the interface they implement.
 A listener can subclass the adapter and override only stub
methods for handling events of interest.
 The table below lists the low level event listener interfaces and
their adapters.
Event Listener interface Event Listener Adapter
ComponentListener ComponentAdapter
ContainerListener ContainerAdapter
FocusListener FocusAdapter
KeyListener KeyAdapter
MouseListener MouseAdapter
MouseMotionListener MouseMotionAdapter
WindowListener WindowAdapter
QUESTION
1. Give full name :AWT ,GUI ,URL
2. Compare Label and JLabel.
3. List out layout managers. Explain any one with
example.
4. Explain Frame class in brief.
5. Explain Panel class in brief.
6. Explain event classes.
7. Explain event listener interfaces.
8. Explain ActionListener interface.
9. Compare : swing(JFC) and AWT controls
Thank you