Swing is the primary Java GUI widget toolkit. It provides more sophisticated and flexible components than AWT, including buttons, labels, text fields, lists, tables, and tabs. Unlike AWT, Swing components are platform-independent and rendered using Java 2D rather than native OS widgets. Swing introduces pluggable look and feels to customize the appearance of components without changing code.

1. Internet
And
Java
Topic: - Java Swings
Submitted To: Submitted By:
As Prof. Shruti Jain Alisha Korpal
Nivia Jain
Sharuti Jain
1|Page

2. Index
S.no Topic Page no.
1 Introduction 3
2 History 4
3 Swing Architecture 5
4 Foundation 6-7
5 Relationship to AWT 8
6 Swing Components 9
7 JFrame 10
8 JLabel 11
9 JButton 12
10 Example 13
11 References 15
2|Page

3. Introduction
Swing is the primary Java GUI widget toolkit. It is part of Java Foundation
Classes (JFC) — an API for providing a graphical user interface (GUI) for Java
programs.
Swing was developed to provide a more sophisticated set of GUI components than the
earlier Abstract Window Toolkit. Swing provides a native look and feel that emulates the
look and feel of several platforms, and also supports a pluggable look and feel that
allows applications to have a look and feel unrelated to the underlying platform. It has
more powerful and flexible components than AWT. In addition to familiar components
such as buttons, check box and labels, Swing provides several advanced components
such as tabbed panel, scroll panes, trees, tables and lists.
Unlike AWT components, Swing components are not implemented by platform-specific
code. Instead they are written entirely in Java and therefore are platform-independent.
The term "lightweight" is used to describe such an element.
3|Page

4. History
The Internet Foundation Classes (IFC) was a graphics library for Java originally
developed by Netscape Communications Corporation and first released on December
16, 1996.
On April 2, 1997, Sun Microsystems and Netscape Communications
Corporation announced their intention to incorporate IFC with other technologies to form
the Java Foundation Classes. The "Java Foundation Classes" were later renamed
"Swing".
Swing introduced a mechanism that allowed the look and feel of every component in an
application to be altered without making substantial changes to the application code.
The introduction of support for a pluggable look and feel allows Swing components to
emulate the appearance of native components while still retaining the benefits of
platform independence. This feature also makes it easy to make an application written
in Swing look very different from native programs if desired.
Originally distributed as a separately downloadable library, Swing has been included as
part of the Java Standard Edition since release 1.2. The Swing classes and components
are contained in the javax.swing package hierarchy.
4|Page

5. Swing Architecture
• Foundations
o Extensible
o Customizable
o Configurable
o Light weight UI
• Relationship to AWT
5|Page

6. Foundations
Swing is platform independent both in terms of expression (Java) and implementation
(Look-and-Feel).
Extensible
Swing is a highly partitioned architecture, which allows for the "plugging" of various
custom implementations of specified framework interfaces: Users can provide their own
custom implementation(s) of these components to override the default implementations.
In general, Swing users can extend the framework by extending existing (framework)
classes and/or providing alternative implementations of core components.
Customizable
Given the programmatic rendering model of the Swing framework, fine control over the
details of rendering of a component is possible in Swing. As a general pattern, the
visual representation of a Swing component is a composition of a standard set of
elements, such as a "border", "inset", decorations, etc. Typically, users will
programmatically customize a standard Swing component (such as a JTable) by
assigning specific Borders, Colors, Backgrounds, opacities, etc., as the properties of
that component. The core component will then use these properties (settings) to
determine the appropriate renderers to use in painting its various aspects. However, it is
also completely possible to create unique GUI controls with highly customized visual
representation.
6|Page

7. Configurable
Swing's heavy reliance on runtime mechanisms and indirect composition patterns
allows it to respond at runtime to fundamental changes in its settings. For example, a
Swing-based application can change its look and feel at runtime. Further, users can
provide their own look and feel implementation, which allows for uniform changes in the
look and feel of existing Swing applications without any programmatic change to the
application code.
Light weight UI
Swing's configurability is a result of a choice not to use the native host OS's GUI
controls for displaying itself. Swing "paints" its controls programmatically through the
use of Java 2D APIs, rather than calling into a native user interface toolkit. Thus, a
Swing component does not have a corresponding native OS GUI component, and is
free to render itself in any way that is possible with the underlying graphics APIs.
However, at its core every Swing component relies on an AWT container, since
(Swing's) JComponent extends (AWT's) Container. This allows Swing to plug into the
host OS's GUI management framework, including the crucial device/screen mappings
and user interactions, such as key presses or mouse movements. Swing simply
"transposes" its own (OS agnostic) semantics over the underlying (OS specific)
components. So, for example, every Swing component paints its rendition on the
graphic device in response to a call to component.paint(), which is defined in (AWT)
Container. But unlike AWT components, which delegated the painting to their OS-native
"heavyweight" widget, Swing components are responsible for their own rendering.
7|Page

8. Relationship to AWT
Since early versions of Java, a portion of the Abstract Window Toolkit (AWT) has
provided platform-independent APIs for user interface components. In AWT, each
component is rendered and controlled by a native peer component specific to the
underlying windowing system.
By contrast, Swing components are often described as lightweight because they do not
require allocation of native resources in the operating system's windowing toolkit. The
AWT components are referred to as heavyweight components.
Much of the Swing API is generally a complementary extension of the AWT rather than
a direct replacement. In fact, every Swing lightweight interface ultimately exists within
an AWT heavyweight component because all of the top-level components in Swing
(JApplet, JDialog,JFrame, and JWindow) extend an AWT top-level container. Prior
to Java 6 Update 10, the use of both lightweight and heavyweight components within
the same window was generally discouraged due to Z-order incompatibilities. However,
later versions of Java have fixed these issues, and both Swing and AWT components
can now be used in one GUI without Z-order issues.
The core rendering functionality used by Swing to draw its lightweight components is
provided by Java 2D, another part of JFC.
8|Page

9. Java Components
9|Page

10. JFrame
The components added to the frame are referred to as its contents; these are managed
by the content Pane. To add a component to a JFrame, we must use its content Pane
instead. JFrame is a Window with border, title and buttons. When JFrame is set visible,
an event dispatching thread is started. JFrame objects store several objects including a
Container object known as the content pane. To add a component to a JFrame, add it to
the content pane.
Creating JFrame Window
Step 1: Construct an object of the JFrame class.
Step 2: Set the size of the JFrame.
Step 3: Set the title of the JFrame to appear in the title bar (title bar will be blank if no
title is set).
Step 4: Set the default close operation. When the user clicks the close button, the
program stops running.
Step 5: Make the JFrame visible.
10 | P a g e

11. JLabel
JLabel, descended from JComponent, is used to create text labels.
A JLabel object provides text instructions or information on a GUI — display a single
line of read-only text, an image or both text and image.
We use a Swing JLabel when we need a user interface component that displays a
message or an image.
11 | P a g e

12. JButton
A button is a component the user clicks to trigger a specific action.
There are several types of buttons in Java, all are subclasses of AbstractButton.
• command buttons: is created with class JButton. It generates ActionEvent.
• toggle buttons: have on/off or true/false values.
• check boxes: a group of buttons. It generates ItemEvent.
• radio buttons: a group of buttons in which only one can be selected. It
generates ItemEvent.
12 | P a g e

13. Example:-
// Import the swing and AWT classes needed
import java.awt.FlowLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.SwingUtilities;
public class SwingExample
{
public static void main(String[] args)
{
SwingUtilities.invokeLater(new Runnable()
{
public void run()
{
JFrame f = new JFrame("Swing Example Window");
f.setLayout(new FlowLayout());
f.add(new JLabel("Hello, world!"));
f.add(new JButton("Press me!"));
f.pack();
f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
f.setVisible(true);
}
}
13 | P a g e

14. );
}
}
14 | P a g e

15. References:
 http://en.wikipedia.org/wiki/Swing_(Java)
 Matthew Robinson, Pavel Vorobiev: Swing, Second Edition, Manning, ISBN
1-930110-88-X
 http://www.google.co.in/#sclient=psy&hl=en&source=hp&q=swings+in+java&pbx
=1&oq=swings+in+java&aq=f&aqi=g5&aql=&gs_sm=e&gs_upl=170399l176171l0
l176515l21l14l1l0l0l2l1764l7815l4-2.2.1.1.2l9l0&bav=on.2,or.r_gc.r_pw.&fp=cc63
231dd3ba60f6&biw=1280&bih=869
 http://docs.google.com/viewer?a=v&q=cache:P8TA9pgDM1YJ:waltermilner.com/
downloads/JavaSwing/Java
%2520Swing.ppt+swings+in+java+ppt&hl=en&gl=in&pid=bl&srcid=ADGEESiEz8
NwezOYwyipXPonXBC0nWcz1oAqRU3dKPsqMlEJzV9_ZTtfxoyBy3gyROz859X
KJYIoS7867YIKWIztvGsvf1wG68QBiyaV65GYPYkeDFfJ8XujEaoQOFWJF-
vmzmGZe0VH&sig=AHIEtbRatSwTaKEOa7DH8iV2tFaZPyCAbQ
15 | P a g e