Subject: Object-Oriented Programming (AIDS 202)

Unit - 3
1. What is multithreading in Java? Explain the difference between extending the Thread class and
implementing the Runnable interface for creating threads.

Multithreading in Java is a process that allows multiple threads to run

concurrently within a single program. A thread is a lightweight sub-process
that can run independently of other threads. Multithreading can improve
the performance and responsiveness of an application by allowing multiple
tasks to be executed simultaneously.
There are two ways to create threads in Java:
By extending the Thread class and By implementing the Runnable interface.

Extending the Thread class

To create a thread by extending the Thread class, you need to create a
class that inherits from the Thread class and override the run()
method. The run() method contains the code that the thread will execute.
Here is an example of a class that extends the Thread class:
Java
public class MyThread extends Thread {
@Override
public void run() {
// Code to be executed by the thread
}
}

To start the thread, you need to create an instance of the class and call the
start() method.
Here is an example of how to start a thread:
Java
MyThread thread = new MyThread();
thread.start();

Implementing the Runnable interface

To create a thread by implementing the Runnable interface, you need to
create a class that implements the Runnable interface. The Runnable
interface has a single method, run(), which contains the code that the
thread will execute.
Here is an example of a class that implements the Runnable interface:
Java
public class MyRunnable implements Runnable {
@Override
public void run() {
// Code to be executed by the thread
}
}

To start the thread, you need to create an instance of the class and pass it
to the Thread constructor.
Here is an example of how to start a thread:
Java
MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start();

Difference between extending the Thread class and implementing the

Runnable interface
The main difference between extending the Thread class and implementing
the Runnable interface is that extending the Thread class limits the class to
being a thread. If you need the class to be able to do something else
besides being a thread, you should implement the Runnable interface
instead.
Another difference is that when you extend the Thread class, you can only
override the run() method. When you implement the Runnable interface,
you can override any method that you want.
In general, it is recommended to implement the Runnable interface instead
of extending the Thread class. This is because it gives you more flexibility
and allows you to reuse the class for other purposes.

2. How do you start a thread in Java? Compare and contrast the methods start() and run() in the
Thread class.

The start() method creates a new thread and then executes the run()
method. The run() method is the entry point for the new thread, and it
contains the code that you want to execute in the new thread.
The start() and run() methods are two important methods in the Thread
class. The main difference between the two methods is whether a new
thread is created:
• start(): Creates a new thread and then executes the run() method.
• run(): Executed as a normal method call on the current calling thread.
In other words, when you call the start() method, a new thread is created
and the run() method is executed in that new thread. When you call the
run() method directly, no new thread is created and the run() method is
executed on the current thread.

3. What is thread synchronization and why is it important in multithreaded programming? Discuss

the different ways to achieve thread synchronization in Java.

Thread synchronization is a mechanism that ensures that multiple threads

can access shared resources safely and correctly. It is important in
multithreaded programming because it prevents data races and other
concurrency problems.

There are two main ways to achieve thread synchronization in Java:

• Using the synchronized keyword:
The synchronized keyword can be used to synchronize a block of code or a
method. When a thread enters a synchronized block, it acquires a lock on the object that the
block is synchronized on. No other thread can enter the synchronized block until the first
thread has released the lock.

• Using locks:
Locks are objects that can be used to explicitly control access to shared resources. A
thread can acquire a lock on an object before accessing the resource, and then release the
lock when it is finished. Other threads cannot access the resource while the lock is held.

Here are some of the benefits of using thread synchronization:

• Prevents data races:
A data race occurs when two or more threads access the same data at the same time and
at least one of the threads is modifying the data. Data races can lead to data corruption and
other problems. Thread synchronization prevents data races by ensuring that only one
thread can access a shared resource at a time.

• Improves performance:
Thread synchronization can improve performance by preventing threads from interfering
with each other. For example, if two threads are trying to access the same file at the same
time, they can interfere with each other and slow down the performance of the
program. Thread synchronization can prevent this from happening by ensuring that only one
thread can access the file at a time.

• Makes code more reliable:

Thread synchronization can make code more reliable by preventing concurrency
problems. Concurrency problems can occur when two or more threads are trying to access
 the same data at the same time and at least one of the threads is modifying the
data. Concurrency problems can lead to data corruption, crashes, and other
problems. Thread synchronization can prevent concurrency problems by ensuring that only
one thread can access a shared resource at a time.

Overall, thread synchronization is an important concept in multithreaded

programming. By using thread synchronization, you can prevent data races
and other concurrency problems, improve performance, and make your
code more reliable.

4. Explain the concept of GUI components in Java. What are AWT and Swing components?
Differentiate between them.

GUI components in Java are the building blocks of graphical user

interfaces (GUIs). They allow users to interact with a computer program by
providing visual elements such as buttons, menus, text fields, and
windows.
There are two main GUI toolkits in Java: the Abstract Window Toolkit
(AWT) and Swing.
AWT is the older of the two toolkits and is platform-dependent, meaning
that the appearance of AWT components will vary depending on the
operating system on which the program is running. AWT components are
also heavyweight, meaning that they consume more system resources than
Swing components.
Swing is a newer toolkit that is platform-independent, meaning that Swing
components will have a consistent look and feel across all operating
systems. Swing components are also lightweight, meaning that they
consume fewer system resources than AWT components.
Here is a table summarizing the key differences between AWT and Swing
components:
In general, Swing is the preferred toolkit for developing GUIs in
Java. However, there are some cases where AWT may be a better choice,
such as when developing applets or when needing to achieve a specific
look and feel that is not possible with Swing.

5. Describe the Component class and Container class in Java GUI programming. How are they related
and what roles do they play in building graphical user interfaces?

In Java GUI programming, the Component class and the Container class
are two fundamental concepts.
The Component class is the base class for all graphical user interface (GUI)
elements in Java. It provides the basic functionality for all GUI elements,
such as visibility, size, and location.
The Container class is a subclass of the Component class. It is a
component that can contain other components. Containers are used to
organize and manage the layout of GUI elements.
Here is a table summarizing the key differences between the Component
class and the Container class:
Components and containers are related in that all containers are
components, but not all components are containers. Containers are used
to organize and manage the layout of components.
Components and containers play an important role in building graphical
user interfaces. Components are the individual building blocks of GUI
elements, while containers are used to organize and manage the layout of
components. By combining these two concepts effectively, Java
developers can create powerful and visually appealing graphical user
interfaces that enhance the overall user experience.

Here are some examples of components and containers:

• Components: Button, Checkbox, TextField, Choice, and Canvas
• Containers: Frame, Panel, and Dialog
To create a GUI in Java, you will need to use both components and
containers. You can use components to create the individual elements of
your GUI, and you can use containers to organize and manage the layout of
those elements.

6. What are layout managers in Java GUI programming? Discuss the commonly used layout managers
and their characteristics.

In Java GUI programming, layout managers are classes that control the
size and position of components within a container. They ensure that
components are arranged in a practical and aesthetically pleasing way, and
that the user interface functions as intended across different platforms and
screen sizes. Layout managers take into account the size of the container,
the preferred size of the components, and any constraints that have been
set for the layout.

Some commonly used layout managers in Java include:

• BorderLayout: The default layout manager for all Window objects, it arranges
components in five fixed areas: North, South, East, West, and Center. Each
region can contain only one component. This layout manager is suitable for
creating interfaces with distinct sections, such as a title bar, content area, and
status bar.
• FlowLayout: Arranges components in a container like the words on a page,
filling the top line from left to right and top to bottom.
• CardLayout: Arranges two or more components having the same size in a
deck, where all the cards of the same size and the only top card are visible at
 any time. The first component added in the container will be kept at the top of
the deck.
• GridLayout: A layout manager in Java. It arranges all the components in a grid
of equally sized cells, adding them from the left to right and top to bottom.
Only one component can be placed in a cell and each region of the grid will
have the same size. When the container is resized, all cells are automatically
resized. The order of placing the components in a cell is determined as they
were added.
• GridBagLayout: A layout manager in Java. It is a powerful layout which
arranges all the components in a grid of cells and maintains the aspect ration
of the object whenever the container is resized. In this layout, cells may be
different in size. It assigns a consistent horizontal and vertical gap among
components. It allows us to specify a default alignment for components
within the columns or rows.
• BoxLayout: It arranges multiple components in either vertically or horizontally,
but not both. The components are arranged from left to right or top to bottom. If the
components are aligned horizontally, the height of all components will be the same
and equal to the largest sized components. If the components are aligned vertically,
the width of all components will be the same and equal to the largest width
components.

7. Explain event handling in Java GUI programming. What are events and listeners? How
do they work together to handle user interactions with graphical components?

Event handling is a fundamental concept in Java GUI programming. It

allows developers to create responsive applications that can react to user
interactions with graphical components.
An event is an object that represents a change in the state of a
component. For example, a button click event is generated when a user
clicks on a button. A mouse move event is generated when a user moves
the mouse over a component.
A listener is an object that is registered to receive notifications about
specific events. When an event occurs, the component generates an event
object and sends it to all of its registered listeners. The listeners can then
handle the event by executing the appropriate code.
For example, to handle a button click event, you would create an
ActionListener object and register it with the button. When the button is
clicked, the button will generate a button click event and send it to the
ActionListener object. The ActionListener object can then handle the event
by executing the code in its actionPerformed() method.

8. Discuss the types of AWT events in Java and how they are handled using event listeners.

In Java, events are used to notify the user interface (UI) components when
something happens. For example, when a user clicks on a button, an event
is generated and sent to the button component. The button component
then handles the event by performing the appropriate action, such as
opening a new window or displaying a message.
There are many different types of AWT events, each of which corresponds
to a different type of user interaction. Some of the most common AWT
events include:
• ActionEvent: This event is generated when a user clicks on a button, selects a
menu item, or double-clicks on a list item.
• KeyEvent: This event is generated when a user presses or releases a key on
the keyboard.
• MouseEvent: This event is generated when a user moves the mouse, clicks on
a mouse button, or presses a mouse wheel.
• TextEvent: This event is generated when a user enters text into a text field or
text area.
• WindowEvent: This event is generated when a window is opened, closed,
moved, or resized.
To handle AWT events, you must register an event listener with the UI
component that you want to monitor. An event listener is an object that
implements one or more of the event listener interfaces, such as
ActionListener, KeyListener, MouseListener, TextListener, or
WindowListener.
When an event occurs, the UI component generates an event object and
sends it to all of the registered event listeners. The event listeners then
process the event object and perform the appropriate action.
For example, the following code shows how to register an ActionListener
with a button:
Java
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
// Handle the event here
}
});
When the user clicks on the button, the actionPerformed() method of the
ActionListener is called. The actionPerformed() method can then perform
the appropriate action, such as opening a new window or displaying a
message.
Event handling is an important part of developing Java applications. By
handling AWT events, you can create UI components that respond to user
interaction in a meaningful way.

9. What is an event listener in Java? Explain the concept of event delegation and how it is
implemented in Java event handling.

In Java, an event listener is an object that is notified when an event

occurs. Events are actions that take place in a program, such as a button
being clicked, a key being pressed, or a window being closed. Event
listeners are registered with event sources, which are the objects that
generate events. When an event occurs, the event source notifies all of its
registered event listeners.
Event delegation is a programming pattern that allows you to handle events
for multiple elements in a GUI using a single event listener. This is done by
registering the event listener with a parent element of the elements that
you want to handle events for. When an event occurs on one of the child
elements, the event is delegated to the parent element, and the event
listener is notified.
Event delegation is implemented in Java using the delegation event
model. In this model, events are propagated up the component hierarchy
until they are handled by a registered event listener. This means that you
can register an event listener with a parent element and it will be notified of
all events that occur on the parent element and its child elements.
10. Describe the various types of events in Java, such as ActionEvent, FocusEvent, KeyEvent,
MouseEvent, and WindowEvent. How are these events generated and handled in Java
applications?

Here is a description of the various types of events in Java, such as

ActionEvent, FocusEvent, KeyEvent, MouseEvent, and WindowEvent, and
how these events are generated and handled in Java applications:
• ActionEvent:
 An ActionEvent is generated when a user performs an action on a component, such as
clicking a button, selecting a menu item, or pressing Enter in a text field. ActionEvents are
handled by objects that implement the ActionListener interface.

• FocusEvent:
A FocusEvent is generated when a component gains or loses input focus. FocusEvents are
handled by objects that implement the FocusListener interface.

• KeyEvent:
A KeyEvent is generated when a user presses or releases a key on the keyboard. KeyEvents
are handled by objects that implement the KeyListener interface.

• MouseEvent:
A MouseEvent is generated when a user interacts with the mouse, such as clicking, moving,
or dragging. MouseEvents are handled by objects that implement the MouseListener
interface.

• WindowEvent:
A WindowEvent is generated when a window is opened, closed, activated, deactivated,
iconified, or deiconified. WindowEvents are handled by objects that implement the
WindowListener interface.

These events are generated by the Java platform and are delivered to the
appropriate listener objects. For example, when a user clicks a button, an
ActionEvent is generated and delivered to all ActionListener objects that
are registered with the button.
To handle events in a Java application, you must first create a listener
object that implements the appropriate interface. For example, to handle
ActionEvents, you would create an object that implements the
ActionListener interface. Once you have created a listener object, you must
register it with the component that will generate the events. For example, to
register an ActionListener object with a button, you would call the button's
addActionListener() method.
When an event is generated, the Java platform will deliver it to all of the
registered listener objects. The listener objects can then take the
appropriate action in response to the event. For example, an ActionListener
object might respond to an ActionEvent by performing some task, such as
updating the contents of a window.