PROGRAMMING LANGUAGE USING JAVA II COM 211 2022

: Event Driven Programs

Week 3-4 Event Driven Programs

Objectives
1. Understand the concepts of event driven programs
2. Understand how to place objects on a frame
3. Write simple event drive programs

Event
Changing the state of an object is known as an event. For example, click on button,
dragging mouse etc. The java.awt.event package provides many event
classes and Listener interfaces for event handling.

Java AWT (Abstract Window Toolkit) is an API to develop Graphical User

Interface (GUI) or windows-based applications in Java.

Java AWT components are platform-dependent i.e. components are displayed

according to the view of operating system. AWT is heavy weight i.e. its
components are using the resources of underlying operating system (OS).

The java.awt package provides classes for AWT API such as TextField, Label,
TextArea, RadioButton, CheckBox, Choice, List etc.

The AWT tutorial will help the user to understand Java GUI programming in
simple and easy steps.

A Graphical User Interface (GUI) presents a user-friendly mechanism for

interacting with an application. A GUI (pronounced "GOO-ee") gives an

C.itp. Obiokafor Ifeyinwa N Page 1

PROGRAMMING LANGUAGE USING JAVA II COM 211 2022
: Event Driven Programs

application a distinctive "look" and "feel." Providing different applications with

consistent, intuitive user interface components allows users to be somewhat
familiar with an application, so that they can learn it more quickly and use it more
productively.

GUIs are built from GUI components. These are sometimes called controls or
widgets short for window gadgets in other languages. A GUI component is an
object with which the user interacts via the mouse, the keyboard or another form of
input, such as voice recognition.

Overview of Swing Components

Though it is possible to perform input and output using the JOptionPane dialogs
presented in earlier weeks, most GUI applications require more elaborate,
customized user interfaces. The remainder of this text discusses many GUI
components that enable application developers to create robust GUIs. Figure 1 lists
several Swing GUI components from package javax.swing that are used to
build Java GUIs. Most Swing components are pure Java components they are
written, manipulated and displayed completely in Java.

C.itp. Obiokafor Ifeyinwa N Page 2

PROGRAMMING LANGUAGE USING JAVA II COM 211 2022
: Event Driven Programs

Figure 1 Class Hierarchy

C.itp. Obiokafor Ifeyinwa N Page 3

PROGRAMMING LANGUAGE USING JAVA II COM 211 2022
: Event Driven Programs

Figure 2 Class Hierarchy JFrame JDialog

C.itp. Obiokafor Ifeyinwa N Page 4

PROGRAMMING LANGUAGE USING JAVA II COM 211 2022
: Event Driven Programs

Displaying Text and Images in a Window

A Frame is a top-level window with a title and a border. The size of the frame
includes any area designated for the border. The dimensions of the border area may
be obtained using the getInsets method. Since the border area is included in the
overall size of the frame, the border effectively obscures a portion of the frame,
constraining the area available for rendering and/or displaying subcomponents to
the rectangle which has an upper-left corner location of (insets.left, insets.top), and
has a size of width - (insets.left + insets.right) by height - (insets.top +
insets.bottom).

To make a window that is dependent on another window — disappearing when the

other window is iconified, for example — use a dialog instead of frame.. To make
a window that appears within another window, use an internal frame.
Our next example introduces a framework for building GUI applications. This
framework uses several concepts that you will see in many of our GUI
applications. This is our first example in which the application appears in its own
window. Most windows you will create are an instance of class JFrame or a
subclass of JFrame.

JFrame
A frame, implemented as an instance of the JFrame class, is a window that has
decorations such as a border, a title, and supports button components that close or
iconify the window. Applications with a GUI usually include at least one frame.
Applets sometimes use frames, as well.

C.itp. Obiokafor Ifeyinwa N Page 5

PROGRAMMING LANGUAGE USING JAVA II COM 211 2022
: Event Driven Programs

JFrame provides the basic attributes and behaviors of a window a title bar at the

top of the window, and buttons to minimize, maximize and close the window.
Since an application's GUI is typically specific to the application, most of our
examples will consist of two classes a subclass of JFrame that helps us
demonstrate new GUI concepts and an application class in which main creates and
displays the application's primary window.

JFrame is a class of the javax.swing package that is extended by java.awt.frame.

This is the top-level window, with border and a title bar. JFrame class has various
methods which can be used to customize it.

JFrame is a top-level container that provides a window on the screen. A frame is

actually a base window, on which other components rely, namely the menu bar,
panels, labels, text fields, buttons, etc. Almost every other Swing application starts
with the JFrame window. Unlike a frame, JFrame has the option to hide or close
the window with the help of the method setDefaultCloseOperation(int).

How to create a JFrame?

JFrame class has many constructors that are used to create a new JFrame. You can

create a JFrame using these methods:

JFrame(): This helps in creating a frame which is invisible.

JFrame(String Title): Helps in creating a frame with a title.

JFrame(GraphicsConfiguration gc): Creates a frame with blank title and the

graphics configuration of screen.

The following FrameDemo code shows how to create and set up a frame.

C.itp. Obiokafor Ifeyinwa N Page 6

PROGRAMMING LANGUAGE USING JAVA II COM 211 2022
: Event Driven Programs

Snippet code for JFrame 1

//1. Create the frame.
JFrame frame = new JFrame("FrameDemo");

//2. Optional: What happens when the frame closes?

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

//3. Create components and put them in the frame.

//...create emptyLabel...
frame.getContentPane().add(emptyLabel, BorderLayout.CENTER);

//4. Size the frame.

frame.pack();
//5. Show it.
frame.setVisible(true);

Snippet code for JFrame 2

1 JFrame F = new JFrame();
2 // Or overload the constructor and give it a title:
3 JFrame F1 = new JFrame("Red Alert!");
Now, after creating the JFrame, you need to set the size and the location. Let’s see
how this can be done.
Snippet code for JFrame 3
1 //add the frame
2 JFrame f = new JFrame("Red Alert!");
3 //set size: width, height (in pixels)
4 f.setSize(450, 475);
5 //set the location (x,y)
6 f.setLocation(120, 60);

C.itp. Obiokafor Ifeyinwa N Page 7

PROGRAMMING LANGUAGE USING JAVA II COM 211 2022
: Event Driven Programs

Snippet code for JFrame 4

1 import java.awt.FlowLayout;
2 import javax.swing.JButton;
3 import javax.swing.JFrame;
4 import javax.swing.JLabel;
5 import javax.swing.Jpanel;
6 public class JFrame pratical{
7 public static void main(String s[]) {
8 JFrame frame = new JFrame("JFrame Example");
9 JPanel panel = new JPanel();
10 panel.setLayout(new FlowLayout());
11 JLabel label = new JLabel("JFrame By Example");
12 JButton button = new JButton();
13 button.setText("Button");
14 panel.add(label);
15 panel.add(button);
16 frame.add(panel);
17 frame.setSize(200, 300);
18 frame.setLocationRelativeTo(null);
19 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
20 frame.setVisible(true);
21 }
22 }
Output:

C.itp. Obiokafor Ifeyinwa N Page 8

PROGRAMMING LANGUAGE USING JAVA II COM 211 2022
: Event Driven Programs

Add a menu bar:

The method setJMenuBar(JMenuBar) is used to add a menu bar to the frame. The
following example code adds a menu bar with a File > Exit menu:

Snippet code for JFrame 1

1 JMenuBar menuBar = new JMenuBar();
2 JMenu menuFile = new JMenu("File");
3 JMenuItem menuItemExit = new JMenuItem("Exit");
4 menuFile.add(menuItemExit);

5 menuBar.add(menuFile);

6 // adds menu bar to the frame

7 frame.setJMenuBar(menuBar);

Labeling GUI Components

A typical GUI consists of many components. In a large GUI, it can be difficult to
identify the purpose of every component unless the GUI designer provides text
instructions or information stating the purpose of each component. Such text is
known as a label and is created with class JLabel a subclass of JComponent. A
JLabel displays a single line of read-only text, an image, or both text and an

image. Applications rarely change a label's contents after creating it. The
application of Example 1 and Example 2 demonstrates several JLabel features and
presents the framework we use in most of our GUI examples. We did not highlight
the code in this example since most of it is new.

C.itp. Obiokafor Ifeyinwa N Page 9

PROGRAMMING LANGUAGE USING JAVA II COM 211 2022
: Event Driven Programs

[Note: There are many more features for each GUI component than we can cover
in our examples. To learn the complete details of each GUI component, visit its
page in the online documentation.
Example 1: LabelFrame.java
1 // Example 1: LabelFrame.java
2 // Demonstrating the JLabel class.
3 import java.awt.FlowLayout; // specifies how components are arranged
4 import javax.swing.JFrame; // provides basic window features
5 import javax.swing.JLabel; // displays text and images
6 import javax.swing.SwingConstants; // common constants used with Swing
7 import javax.swing.Icon; // interface used to manipulate images
8 import javax.swing.ImageIcon; // loads images
9
10 public class LabelFrame extends JFrame
11 {
12 private JLabel label1; // JLabel with just text
13 private JLabel label2; // JLabel constructed with text and icon
14 private JLabel label3; // JLabel with added text and icon
15
16 // LabelFrame constructor adds JLabels to JFrame
17 public LabelFrame()
18 {
19 super( "Testing JLabel" );
20 setLayout( new FlowLayout() ); // set frame layout
21
22 // JLabel constructor with a string argument
23 label1 = new JLabel( "Label with text" );
24 label1.setToolTipText( "This is label1" );
25 add( label1 ); // add label1 to JFrame
26

C.itp. Obiokafor Ifeyinwa N Page 10

PROGRAMMING LANGUAGE USING JAVA II COM 211 2022
: Event Driven Programs
27 // JLabel constructor with string, Icon and alignment arguments
28 Icon bug = new ImageIcon( getClass().getResource( "bug1.gif"
) );
29 label2 = new JLabel( "Label with text and icon", bug,
30 SwingConstants.LEFT );
31 label2.setToolTipText( "This is label2" );
32 add( label2 ); // add label2 to JFrame
33
34 label3 = new JLabel(); // JLabel constructor no arguments
35 label3.setText( "Label with icon and text at bottom" );
36 label3.setIcon( bug ); // add icon to JLabel
37 label3.setHorizontalTextPosition( SwingConstants.CENTER );
38 label3.setVerticalTextPosition( SwingConstants.BOTTOM );
39 label3.setToolTipText( "This is label3" );
40 add( label3 ); // add label3 to JFrame
41 } // end LabelFrame constructor
42 } // end class LabelFrame

Example 2: LabelTest.java
1 // Example 2: LabelTest.java
2 // Testing LabelFrame.
3 import javax.swing.JFrame;
4
5 public class LabelTest
6 {
7 public static void main( String args[] )
8 {
9 LabelFrame labelFrame = new LabelFrame(); // create LabelFrame
10 labelFrame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
11 labelFrame.setSize( 275, 180 ); // set frame size

C.itp. Obiokafor Ifeyinwa N Page 11

PROGRAMMING LANGUAGE USING JAVA II COM 211 2022
: Event Driven Programs
12 labelFrame.setVisible( true ); // display frame
13 } // end main
14 } // end class LabelTest

Figure 4 Output sample

Text Fields and an Introduction to Event Handling with Nested Classes
Normally, a user interacts with an application's GUI to indicate the tasks that the
application should perform. For example, when you write an e-mail in an e-mail
application, clicking the Send button tells the application to send the e-mail to the
specified e-mail addresses. GUIs are event driven, when the user interacts with a
GUI component, the interaction known as an event drives the program to perform a
task. Some common events (user interactions) that might cause an application to
perform a task include clicking a button, typing in a text field, selecting an item
from a menu, closing a window and moving the mouse. The code that performs a
task in response to an event is called an event handler and the overall process of
responding to events is known as event handling.

In this section, we introduce two new GUI components that can generate events
JTextFields and JPasswordFields (package javax.swing). Class
JTextField extends class JTextComponent (package javax.swing.text),

which provides many features common to Swing's text-based components. Class

JPasswordField extends JTextField and adds several methods that are specific

C.itp. Obiokafor Ifeyinwa N Page 12

PROGRAMMING LANGUAGE USING JAVA II COM 211 2022
: Event Driven Programs

to processing passwords. Each of these components is a single-line area in which

the user can enter text via the keyboard. Applications can also display text in a
JTextField (Figure 4). A JPasswordField shows that characters are being typed

as the user enters them, but hides the actual characters with an echo character,
assuming that they represent a password that should remain known only to the
user.

When the user types data into a JTextField or a JPasswordField, then presses Enter,
an event occurs. Our next example demonstrates how a program can perform a task
when that event occurs. The techniques shown here are applicable to all GUI
components that generate events. The application of example 3 and example 4 uses
classes JTextField and JPasswordField to create and manipulate four text
fields. When the user types in one of the text fields, then presses Enter, the
application displays a message dialog box containing the text the user typed. You
can only type in the text field that is "in focus." A component receives the focus
when the user clicks the component. This is important because the text field with
the focus is the one that generates an event when the user presses Enter. In this
example, when the user presses Enter in the JPasswordField, the password is
revealed. We begin by discussing the setup of the GUI, then discuss the event-
handling code.

Example 3
1 // Example 3: TextFieldFrame.java
2 // Demonstrating the JTextField class.
3 import java.awt.FlowLayout;
4 import java.awt.event.ActionListener;

C.itp. Obiokafor Ifeyinwa N Page 13

PROGRAMMING LANGUAGE USING JAVA II COM 211 2022
: Event Driven Programs
5 import java.awt.event.ActionEvent;
6 import javax.swing.JFrame;
7 import javax.swing.JTextField;
8 import javax.swing.JPasswordField;
9 import javax.swing.JOptionPane;
10
11 public class TextFieldFrame extends JFrame
12 {
13 private JTextField textField1; // text field with set size
14 private JTextField textField2; // text field constructed with
text
15 private JTextField textField3; // text field with text and
size
16 private JPasswordField passwordField; // password field with
text
17
18 // TextFieldFrame constructor adds JTextFields to JFrame
19 public TextFieldFrame()
20 {
21 super( "Testing JTextField and JPasswordField" );
22 setLayout( new FlowLayout() ); // set frame layout
23
24 // construct textfield with 10 columns
25 textField1 = new JTextField( 10 );
26 add( textField1 ); // add textField1 to JFrame
27
28 // construct textfield with default text
29 textField2 = new JTextField( "Enter text here" );
30 add( textField2 ); // add textField2 to JFrame
31

C.itp. Obiokafor Ifeyinwa N Page 14

PROGRAMMING LANGUAGE USING JAVA II COM 211 2022
: Event Driven Programs
32 // construct textfield with default text and 21 columns
33 textField3 = new JTextField( "Uneditable text field", 21 );
34 textField3.setEditable( false ); // disable editing
35 add( textField3 ); // add textField3 to JFrame
36
37 // construct passwordfield with default text
38 passwordField = new JPasswordField( "Hidden text" );
39 add( passwordField ); // add passwordField to JFrame
40
41 // register event handlers
42 TextFieldHandler handler = new TextFieldHandler();
43 textField1.addActionListener( handler );
44 textField2.addActionListener( handler );
45 textField3.addActionListener( handler );
46 passwordField.addActionListener( handler );
47 } // end TextFieldFrame constructor
48
49 // private inner class for event handling
50 private class TextFieldHandler implements ActionListener
51 {
52 // process text field events
53 public void actionPerformed( ActionEvent event )
54 {
55 String string = ""; // declare string to display
56
57 // user pressed Enter in JTextField textField1
58 if ( event.getSource() == textField1 )
59 string = String.format( "textField1: %s",
60 event.getActionCommand() );
61

C.itp. Obiokafor Ifeyinwa N Page 15

PROGRAMMING LANGUAGE USING JAVA II COM 211 2022
: Event Driven Programs
62 // user pressed Enter in JTextField textField2
63 else if ( event.getSource() == textField2 )
64 string = String.format( "textField2: %s",
65 event.getActionCommand() );
66
67 // user pressed Enter in JTextField textField3
68 else if ( event.getSource() == textField3 )
69 string = String.format( "textField3: %s",
70 event.getActionCommand() );
71
72 // user pressed Enter in JTextField passwordField
73 else if ( event.getSource() == passwordField )
74 string = String.format( "passwordField: %s",
75 new String( passwordField.getPassword() ) );
76
77 // display JTextField content
78 JOptionPane.showMessageDialog( null, string );
79 } // end method actionPerformed
80 } // end private inner class TextFieldHandler
81 } // end class TextFieldFrame

Example 4.
1 // Fig. 13.3: TextFieldTest.java
2 // Testing TextFieldFrame.
3 import javax.swing.JFrame;
4
5 public class TextFieldTest
6 {
7 public static void main( String args[] )
8 {

C.itp. Obiokafor Ifeyinwa N Page 16

PROGRAMMING LANGUAGE USING JAVA II COM 211 2022
: Event Driven Programs
9 TextFieldFrame textFieldFrame = new TextFieldFrame();
10 textFieldFrame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE
);
11 textFieldFrame.setSize( 325, 100 ); // set frame size
12 textFieldFrame.setVisible( true ); // display frame
13 } // end main
14 } // end class TextFieldTest

Figure 5 sample Output

Lines 39 import the classes and interfaces we use in this example. Class
TextFieldFrame extends JFrame and declares three JTextField variables
and a JPasswordField variable (lines 13-16). Each of the corresponding text
fields is instantiated and attached to the TextFieldFrame in the constructor (lines
19 to 47)

C.itp. Obiokafor Ifeyinwa N Page 17

PROGRAMMING LANGUAGE USING JAVA II COM 211 2022
: Event Driven Programs

Creating the GUI

Line 22 sets the layout of the TextFieldFrame to FlowLayout.
Line 25 creates textField1 with 10 columns of text. The width in pixels of a text
column is determined by the average width of a character in the text field's current
font. When text is displayed in a text field and the text is wider than the text field
itself, a portion of the text at the right side is not visible. If you are typing in a text
field and the cursor reaches the right edge of the text field, the text at the left edge
is pushed off the left side of the text field and will no longer be visible. Users can
use the left and right arrow keys to move through the complete text even though
the entire text will not be visible at one time.
Line 26 adds textField1 to the JFrame.
Line 29 creates textField2 with the initial text "Enter text here" to display in the
text field. The width of the text field is determined by the width of the default text
specified in the constructor.
Line 30 adds textField2 to the JFrame.
Line 33 creates textField3 and calls the JTextField constructor with two
arguments the default text "Uneditable text field" to display and the number of
columns (21). The width of the text field is determined by the number of columns
specified.
Line 34 uses method setEditable (inherited by JTextField from class
JTextComponent) to make the text field uneditable, that is, the user cannot modify

the text in the text field.

Line 35 adds textField3 to the JFrame.

C.itp. Obiokafor Ifeyinwa N Page 18

PROGRAMMING LANGUAGE USING JAVA II COM 211 2022
: Event Driven Programs

Line 38 creates passwordField with the text "Hidden text" to display in the text
field. The width of the text field is determined by the width of the default text.
When you execute the application, notice that the text is displayed as a string of
asterisks.
Line 39 adds passwordField to the JFrame.

Steps Required to Set Up Event Handling for a GUI Component.

This example should display a message dialog containing the text from a text field
when the user presses Enter in that text field. Before an application can respond to
an event for a particular GUI component, you must perform several coding steps:
1. Create a class that represents the event handler.
2. Implement an appropriate interface, known as an event-listener
interface, in the class from Step
3. Indicate that an object of the class from Steps 1 and 2 should be notified when
the event occurs.
This is known as registering the event handler

Using a Nested Class to Implement an Event Handler

All the classes discussed so far were so-called top-level classes that is, the
classes were not declared inside another class. Java allows you to declare classes
inside other classes these are called nested classes. Nested classes can be
static or non-static. Non-static nested classes are called inner classes

and are frequently used for event handling. Before an object of an inner class can
be created, there must first be an object of the top-level class that contains the inner

C.itp. Obiokafor Ifeyinwa N Page 19

PROGRAMMING LANGUAGE USING JAVA II COM 211 2022
: Event Driven Programs

class. This is required because an inner-class object implicitly has a reference to an

object of its top-level class.

There is also a special relationship between these objects the inner-class object is
allowed to directly access all the instance variables and methods of the outer class.
A nested class that is static does not require an object of its top-level class and
does not implicitly have a reference to an object of the top-level class.

The event handling in this example is performed by an object of the private inner
class TextFieldHandler (lines 50-80). This class is private because it will be
used only to create event handlers for the text fields in top-level class
TextFieldFrame. As with other members of a class, inner classes can be declared
public, protected or private.

GUI components can generate a variety of events in response to user interactions.

Each event is represented by a class and can be processed only by the appropriate
type of event handler. In most cases, the events a GUI component supports are
described in the Java API documentation for that component's class and its
superclasses. When the user presses Enter in a JTextField or JPasswordField,
the GUI component generates an ActionEvent (package java.awt.event).
Such an event is processed by an object that implements the interface
ActionListener (package java.awt.event). The information discussed here is

available in the Java API documentation for classes JTextField and

ActionEvent. Since JPasswordField is a subclass of JTextField,

JPasswordField supports the same events. To prepare to handle the events in this

C.itp. Obiokafor Ifeyinwa N Page 20

PROGRAMMING LANGUAGE USING JAVA II COM 211 2022
: Event Driven Programs

example, inner class TextFieldHandler implements interface ActionListener

and declares the only method in that interface action-Performed (lines 53-79).
This method specifies the tasks to perform when an ActionEvent occurs. So inner
class TextFieldHandler satisfies Steps 1 and 2 listed earlier in this section. We'll
discuss the details of method actionPerformed shortly.

Registering the Event Handler for Each Text Field

In the TextFieldFrame constructor, line 42 creates a TextFieldHandler object
and assigns it to variable handler. This object's actionPerformed method will
be called automatically when the user presses Enter in any of the GUI's text fields.
However, before this can occur, the program must register this object as the event
handler for each text field. Lines 43-46 are the event registration statements that
specify handler as the event handler for the three JTextFields and the
JPasswordField. The application calls JTextField method
addActionListener to register the event handler for each component. This

method receives as its argument an ActionListener object, which can be an

object of any class that implements ActionListener. The object handler is an
ActionListener, because class TextFieldHandler implements
ActionListener. After lines 43-46 execute, the object handler listens for events.

Now, when the user presses Enter in any of these four text fields, method
actionPerformed (line 53-79) in class TextFieldHandler is called to handle
the event. If an event handler is not registered for a particular text field, the event
that occurs when the user presses Enter in that text field is consumed that it, it is
simply ignored by the application.

C.itp. Obiokafor Ifeyinwa N Page 21

PROGRAMMING LANGUAGE USING JAVA II COM 211 2022
: Event Driven Programs

Details of Class TextFieldHandler's actionPerformed Method.

In this example, we are using one event-handling object's actionPerformed
method (lines 53-79) to handle the events generated by four text fields. Since we
would like to output the name of each text field's instance variable for
demonstration purposes, we must determine which text field generated the event
each time actionPerformed is called. The GUI component with which the user
interacts is the event source. In this example, the event source is one of the text
fields or the password field. When the user presses Enter while one of these GUI
components has the focus, the system creates a unique ActionEvent object that
contains information about the event that just occurred, such as the event source
and the text in the text field. The system then passes this ActionEvent object in a
method call to the event listener's actionPerformed method. In this example, we
display some of that information in a message dialog. Line 55 declares the String
that will be displayed. The variable is initialized with the empty string a string
containing no characters. The compiler requires this in case none of the branches
of the nested if in lines 58-75 executes

ActionEvent method getSource (called in lines 58, 63, 68 and 73) returns a

reference to the event source. The condition in line 58 asks, "Is the event source
textField1?" This condition compares the references on either side of the ==

operator to determine whether they refer to the same object. If they both refer to
textField1, then the program knows that the user pressed Enter in textField1.

In this case, lines 59-60 create a String containing the message that line 78 will
display in a message dialog. Line 60 uses ActionEvent method
getActionCommand to obtain the text the user typed in the text field that generated

C.itp. Obiokafor Ifeyinwa N Page 22

PROGRAMMING LANGUAGE USING JAVA II COM 211 2022
: Event Driven Programs

the event. If the user interacted with the JPasswordField, lines 74-75 use
JPasswordField method getPassword to obtain the password and create the

String to display. This method returns the password as an array of type char that

is used as an argument to a String constructor to create a string containing the

characters in the array.

C.itp. Obiokafor Ifeyinwa N Page 23

PROGRAMMING LANGUAGE USING JAVA II COM 211 2022
: Event Driven Programs

https://www.edureka.co/blog/java-jframe/
https://docs.oracle.com/javase/tutorial/uiswing/components/frame.html

C.itp. Obiokafor Ifeyinwa N Page 24