UNIT-4 JAVA

GUI Programming

AWT (Abstract Window Toolkit) is a part of the Java Foundation Classes

(JFC) used to create GUI (Graphical User Interface) or window-based
applications. It provides platform-independent libraries but relies on native
OS components for rendering, making it a heavyweight and platform-
dependent application.

 Part of [Link] package.

 Provides GUI components like Button, Label, TextField, Checkbox,

Choice, List, Canvas, etc.

 Heavyweight components: Depend on the underlying OS for look

and feel.

 Platform-dependent appearance: AWT apps look like Windows apps

on Windows, Mac apps on macOS, etc.

Designing GUI in Java:

A Graphical User Interface (GUI) enables users to interact with digital

devices through graphical elements like icons and buttons. Replacing
complex text-based commands, GUIs simplify tasks and enhance user
experience. This article explores GUI’s components, features, benefits,
and examples.

 Function: Displays interactive graphics for user actions and

information.

 Accessibility: Standard in operating systems (e.g., Windows,

macOS) and apps.

 Goal: Makes computing easy, efficient, and visually engaging.

Types of Containers in Java AWT

There are four types of containers in Java AWT:

 Window: Window is a top-level container that represents a

graphical window or dialog box. The Window class extends the
Container class, which means it can contain other components, such
as buttons, labels and text fields.

 Panel: Panel is a container class in Java. It is a lightweight container

that can be used for grouping other components within a window or
a frame.

 Frame: The Frame is the container that contains the title bar and
border and can have menu bars.

 Dialog: A dialog box is a temporary window an application creates

to retrieve user input.

Components of GUI

A graphical user interface (GUI) comprises visual components like cursors,

icons, and buttons, enriched with sound and visual effects. These
elements enable users to interact with a computer without needing to
know specific commands. Below are the components of a Graphical User
Interface:
Components of a Graphical User Interface

 Icons: Small images representing files, folders, or actions.

 Pointers: Cursor symbols (e.g., arrows) for selecting items.

 Pointing Tools: Mouse or trackpad to move pointers.

 Menus: Lists of clickable options for navigation.

 Buttons: Clickable elements to trigger actions.

 Scrollbars: Enables navigation through content beyond the visible

area.

 Window: Contains applications or documents for user interaction.

 Tab: Separates content or functions within a single window.

 Text Fields: Input areas for typing data, such as search bars or
form fields.

 Toolbars: Rows of buttons or icons for quick access to common

commands (e.g., "Bold" or "Undo" in a text editor).
Design Principles of Effective GUIs

Explaining these principles helps understand what makes a user interface

easy to use and why design choices matter.

Key Points:

 Consistency: Keep design elements, like buttons, the same across

the interface.

 Simplicity: Avoid clutter to make it easier for users to focus.

 Feedback: Provide cues, like highlighting buttons on hover, to show

the system is responding.

 Accessibility: Ensure the interface works for everyone, including

support for screen readers and keyboard navigation.

 Responsiveness: Ensure the interface works quickly, even on

slower devices.

Features of GUI

 The graphical user interface (GUI) is very easy to use and the user
can modify and simplify the requirements.

 The required software, documents, or a few relevant programs are

reflected in the icons on the user interface to control the overall
processes properly.

 A graphical user interface (GUI) has several features as per

requirement, such as tabs, a menu, pointers, and various other
types of things to simplify and process smoothly.

Real-World Impact of GUIs

Showing how GUIs impact daily life helps readers relate and understand
their importance.

 Healthcare: Touch-based GUIs on medical devices make it easier

and faster to enter patient data.

 Gaming: GUIs provide immersive experiences, enhancing gameplay

on consoles and PCs.

 Education: Interactive GUIs in educational apps make learning fun

and engaging for students.

GUIs simplify tasks across industries. They speed up data entry on

medical devices. In gaming, they create engaging experiences. In
education, they make learning interactive and accessible for students.
Comparison with Command-Line Interfaces (CLIs)

Comparing GUIs with CLIs helps highlight why GUIs are preferred for most
users while recognizing the strengths of CLIs.

GUI (Graphical User Interface) CLI (Command-Line Interface)

Easier for beginners with visual Requires technical knowledge

elements like buttons and icons. and memorization of commands.

More resource-intensive (requires

Lightweight, uses fewer system
more memory and processing
resources.
power).

Slower for advanced tasks, less Faster and more precise, ideal for
precise control. complex tasks or automation.

In Java, the term "components" can refer to different aspects depending

on the context, primarily in Graphical User Interface (GUI) programming
and the broader Java platform architecture.

GUI Components (AWT and Swing)

In the context of GUI development, a component is a visual element that

can be displayed on the screen and interact with the user.

 [Link]:

This is the abstract superclass for all non-menu-related Abstract Window

Toolkit (AWT) components. Examples include Button, Label, TextField,
and Canvas.

 Heavyweight Components: AWT components are

traditionally "heavyweight" because they are associated with
a native peer (a corresponding component in the operating
system's GUI toolkit).

 [Link]:

This is the base class for all Swing UI components. Swing components are
generally "lightweight," meaning they are drawn entirely by Java code and
do not rely on native peers, offering more platform independence and
customization. Examples include JButton, JLabel, JTextField, JTable,
and JPanel.

 Containers: Components are often placed within containers,

which are also types of components designed to hold other
components (e.g., JFrame, JPanel, JDialog).

Java Platform Components

More broadly, the Java platform itself is composed of several key

components that enable Java applications to run:

 Java Virtual Machine (JVM):

This is the core component that executes Java bytecode. It provides a

runtime environment for Java applications and is responsible for memory
management, garbage collection, and thread management.

 Java Runtime Environment (JRE):

The JRE includes the JVM and the necessary class libraries and other files
to run Java applications. It does not include development tools like
compilers or debuggers.

 Java Development Kit (JDK):

The JDK is a superset of the JRE and includes all the tools required for
developing, compiling, and running Java applications, such as the Java
compiler (javac), debugger, and other utilities.

 Java APIs (Packages and Classes):

These are pre-written libraries of classes and interfaces that provide a

vast range of functionalities, from basic data structures and I/O operations
to networking, database connectivity, and GUI development
(e.g., [Link], [Link], [Link], [Link], [Link], [Link], [Link]).

Java AWT/Swing GUI Containers:

In Java's Abstract Window Toolkit (AWT) and Swing libraries, a Container is

a type of Component that can hold and manage other Components,
including other Containers. These are fundamental for building graphical
user interfaces (GUIs).

 Examples: JFrame, JPanel, JDialog, JApplet.

 Purpose: To organize and group GUI elements (buttons, labels, text

fields, etc.) within a window or a part of a window.
  Key Methods: add(), remove(), setLayout(), getComponents().

 Layout Managers: Containers use layout managers

(e.g., FlowLayout, BorderLayout, GridLayout) to control the
positioning and sizing of their contained components.

Example of an AWT/Swing Container:

LAYOUT CONTAINER IN JAVA

Layout managers in Java are objects responsible for automatically

managing the arrangement, sizing, and positioning of components within
a container (like JFrame, JPanel, or JApplet). They provide a flexible and
platform-independent way to create graphical user interfaces (GUIs) that
can adapt to different screen sizes and resolutions.

Here are some of the common layout managers in Java:

 FlowLayout:

 Arranges components in a row, from left to right, wrapping to

the next line if there isn't enough space.
  Components are typically centered by default, but alignment
can be adjusted.

 Default layout for JPanel and Applet.

 BorderLayout:

 Divides the container into five regions: North, South, East,

West, and Center.

 Each region can hold only one component.

 The Center region expands to fill any remaining space.

 Default layout for JFrame and JApplet.

 GridLayout:

 Arranges components in a rectangular grid of rows and

columns.

 All cells in the grid are of equal size.

 Components are added from left to right, then top to bottom.

 CardLayout:

 Manages multiple components (like panels) as a stack of

"cards," displaying only one at a time.

 Allows switching between different views within the same

container, similar to a tabbed interface.

 GridBagLayout:

 The most flexible and complex layout manager.

 Arranges components in a grid, but allows components to

span multiple rows and columns.

 Offers fine-grained control over component placement, sizing,

and spacing using GridBagConstraints.

 BoxLayout:

 Arranges components either horizontally (along the X-axis) or

vertically (along the Y-axis).

 Useful for creating linear arrangements of components, like

toolbars or menus.

How to Use Layout Managers:

You set the layout manager for a container using its setLayout() method:
Java

[Link](new FlowLayout()); // Example for FlowLayout

Then, you add components to the container, and the chosen layout
manager handles their placement. For layout managers
like BorderLayout and CardLayout, you provide constraints when adding
components to specify their region or name.

AWT COMPONENTS in JAVA

The Java Abstract Window Toolkit (AWT) provides a set of core components
for building Graphical User Interfaces (GUIs). These components are
objects that can be displayed on the screen and allow user interaction.

Key AWT Components:

 Containers:

These components are designed to hold and manage other components.

 Frame: A top-level window with a title bar, border, and

optional menu bar, providing a resizable canvas for other
components.

 Panel: A general-purpose container that can group other

components and containers.

 Window: A top-level container without a border or title bar.

 Dialog: A specialized window used for temporary interactions

and information display.

 User Interface Controls:

These components allow users to interact with the application.

 Button: A push button that triggers an action when clicked.

 Label: Displays static text.

 TextField: Allows single-line text input from the user.

 TextArea: Allows multi-line text input from the user.

 Checkbox: Represents a two-state option (checked or

unchecked).

 CheckboxGroup: Manages a group of checkboxes, ensuring

only one can be selected at a time (radio button functionality).
  Choice: A drop-down list (combobox) for selecting one item
from a list of options.

 List: A scrollable list of items from which one or more can be

selected.

 Scrollbar: A component for scrolling content within a viewable

area.

 Canvas: A blank drawing area where custom graphics can be

rendered.

 Menu Components:

 MenuBar: The main menu bar of a Frame.

 Menu: A single menu within a MenuBar.

 MenuItem: An individual item within a Menu.

 CheckboxMenuItem: A menu item that can be checked or

unchecked.

 PopupMenu: A context-sensitive menu that appears when a

specific mouse action occurs (e.g., right-click).

These components are part of the [Link] package and form the
foundation for creating graphical applications in Java using AWT.

Swing is a Java Foundation Classes [JFC] library and an extension of the

Abstract Window Toolkit [AWT]. Java Swing offers much-improved
functionality over AWT, new components, expanded components features,
and excellent event handling with drag-and-drop support.

Introduction of Java Swing

Swing has about four times the number of User Interface [UI] components
as AWT and is part of the standard Java distribution. By today's application
GUI requirements, AWT is a limited implementation, not quite capable of
providing the components required for developing complex GUIs required
in modern commercial applications. The AWT component set has quite a
few bugs and does take up a lot of system resources when compared to
equivalent Swing resources. Netscape introduced its Internet Foundation
Classes [IFC] library for use with Java. Its Classes became very popular
with programmers creating GUI's for commercial applications.

 Swing is a Set of API (API- Set of Classes and Interfaces)

  Swing is Provided to Design Graphical User Interfaces

 Swing is an Extension library to the AWT (Abstract Window Toolkit)

 Includes New and improved Components that have been enhancing

the looks and Functionality of GUIs'

 Swing can be used to build (Develop) The Standalone swing GUI

Apps as Servlets and Applets

 It Employs model/view design architecture.

 Swing is more portable and more flexible than AWT, the Swing is
built on top of the AWT.

 Swing is Entirely written in Java.

 Java Swing Components are Platform-independent, and The Swing

Components are lightweight.

 Swing Supports a Pluggable look and feel and Swing provides more
powerful components.

 such as tables, lists, Scrollpanes, Colourchooser, tabbed pane, etc.

 Further Swing Follows MVC.

Difference between Java Swing and Java AWT

There are certain points from which Java Swing is different than Java AWT
as mentioned below:

Java AWT Java Swing

Swing is a part of Java Foundation

Java AWT is an API to develop GUI
Classes and is used to create
applications in Java.
various applications.

Components of AWT are heavy The components of Java Swing are

weighted. lightweight.

Components are platform Components are platform

dependent. independent.

Execution Time is more than Execution Time is less than AWT.

Java AWT Java Swing

Swing.

AWT components require [Link] Swing components requires

package. [Link] package.

Features Of Swing Class

 Pluggable look and feel.

 Uses MVC architecture.

 Lightweight Components

 Platform Independent

 Advanced features such as JTable, JTabbedPane, JScollPane, etc.

 Java is a platform-independent language and runs on any client

machine, the GUI look and feel, owned and delivered by a platform-
specific O/S, simply does not affect an application's GUI constructed
using Swing components.

 Lightweight Components: Starting with the JDK 1.1, its AWT-

supported lightweight component development. For a component to
qualify as lightweight, it must not depend on any non-Java [O/s
based) system classes. Swing components have their own view
supported by Java's look and feel classes.

 Pluggable Look and Feel: This feature enable the user to switch
the look and feel of Swing components without restarting an
application. The Swing library supports components' look and feels
that remain the same across all platforms wherever the program
runs. The Swing library provides an API that gives real flexibility in
determining the look and feel of the GUI of an application

 Highly customizable - Swing controls can be customized in a very

easy way as visual appearance is independent of internal
representation.

 Rich controls- Swing provides a rich set of advanced controls like

Tree TabbedPane, slider, colorpicker, and table controls.
JAVA UTILITIES ([Link] PACKAGE)

The [Link] package in Java provides a comprehensive set of

utility classes and interfaces for various common programming
tasks. It is a fundamental part of the Java Standard Library.

Key functionalities and components within [Link] include:

 Collections Framework: This is a major part of [Link],

offering interfaces (like List, Set, Queue, Map) and their
concrete implementations (like ArrayList, HashSet,
HashMap, LinkedList, TreeSet, TreeMap). These are used for
storing and manipulating groups of objects.

 Date and Time Utilities: Classes like Date, Calendar, and

TimeZone provide functionalities for working with dates,
times, and time zones. (Note: Modern Java applications
often prefer the [Link] package for more robust date and
time handling).

 Random Number Generation: The Random class is used to

generate pseudo-random numbers. [1]

 String Parsing and Scanning: The Scanner class allows

parsing of primitive types and strings from various input
sources using regular expressions. StringTokenizer is
another class for breaking strings into tokens.

 Base64 Encoding and Decoding: The Base64 class and its

nested Encoder and Decoder classes provide utilities for
Base64 encoding and decoding.

 Event Model: Classes like EventObject and

EventListenerProxy support the Java Beans event model.

 Miscellaneous Utilities: This category includes classes like

UUID for universally unique identifiers, BitSet for efficient
manipulation of bit arrays, Formatter for printf-style
formatting, and Arrays for manipulating arrays.

To use classes and interfaces from [Link], you typically use an

import statement at the beginning of your Java source file, either
importing specific classes (e.g., import [Link];) or the
entire package (e.g., import [Link].*;).

Java Collections Tutorial

Java Collection Framework (JCF) is a set of classes and interfaces
that provide ready-made data structures to store and manipulate
groups of objects efficiently.

 Java provides built-in collection classes like List, Set, Map

and Queue, so developers don’t need to write their own data
management algorithms.

 The Collection Framework improves productivity by making

code more reusable, maintainable and faster to develop.

Features of Java Collection Framework

 Provides ready-to-use data structures (e.g., ArrayList,

HashSet, HashMap).9

 Offers interfaces (Collection, List, Set, Map, Queue) to define

standard behaviors.

 Supports dynamic resizing, unlike arrays with a fixed size.

 Includes algorithms (sorting, searching, iteration) via the

Collections utility class.

 Improves code reusability and performance by reducing

boilerplate code.

Real World Example

Suppose you are managing a library where thousands of books
need to be stored, searched and retrieved. Instead of arranging
them manually in different shelves every time, you use a catalog
system. Similarly, the Java Collection Framework acts as a catalog
that organizes and manages objects efficiently.

The Collection Framework in Java provides a set of interfaces and

classes to represent and manipulate collections of objects.

Collections of Objects:

The core idea is to group multiple objects into a single unit. This
allows for efficient storage, retrieval, and manipulation of these
objects.
Collection Types:

The framework defines several interfaces that categorize

different types of collections:

 List:

An ordered collection (sequence) that allows duplicate

elements. Elements can be accessed by their integer
index. Examples: ArrayList, LinkedList.

 Set:

A collection that does not allow duplicate elements. It models the

mathematical set abstraction. Examples: HashSet, TreeSet.

 Queue:

A collection designed for holding elements prior to processing. It

typically orders elements in a FIFO (First-In, First-Out)
manner. Examples: PriorityQueue, ArrayDeque.

 Map:

An object that maps keys to values. A Map cannot contain

duplicate keys; each key can map to at most one
value. Examples: HashMap, TreeMap.

Understanding Hashing:

Hashing is a technique used to map data of arbitrary size to data

of a fixed size. In the context of collections, it's primarily used in
hash-based data structures like HashSet and HashMap.

 Hash Code: An integer value generated by

the hashCode() method of an object, representing its unique
identity.

 Hash Function: The algorithm used to convert a key into an

index within a hash table.

 Collision: Occurs when two different keys produce the same

hash code. Hash-based collections use various strategies
(e.g., separate chaining, open addressing) to handle
collisions.

Use of ArrayList & Vector:

 ArrayList: A resizable-array implementation of

the List interface. It provides fast random access (getting an
element by index) but can be slower for insertions and
 deletions in the middle of the list as elements need to be
shifted. ArrayList is not synchronized, meaning it's not
thread-safe by default.

Java

ArrayList<String> names = new ArrayList<>();

[Link]("Alice");
[Link]("Bob");
[Link]([Link](0)); // Output: Alice

 Vector: Similar to ArrayList, Vector also implements a

dynamic array. However, Vector is synchronized, making it
thread-safe. This synchronization comes with a performance
overhead, so ArrayList is generally preferred in single-
threaded environments. Vector is a legacy class and is less
commonly used in modern Java development compared
to ArrayList.