QUESTION-

Q-1. ) What is compile time polymorphism and its importance? Use the compile time
polymorphism in a Java program to create the objects.

Q-2= Discuss method loading and overriding with example in Java.

Q3- What is byte code in JVM?

Q4- What do you know to be multithreading?

Q4- Compare Swing API and AWT API.

Q-5. Differentiate any character stream classes in Java.

Q-6 Differentiate between String, StringBuffer, and StringBuilder.?

Q-7 Explain multi catch statement with an example.

Q-8.How can we make a thread to wait for specific time?

Q-9- Differentiate between Panel and Frame with example.

Q 10- Write a Java program that takes user input for the radius of a circle and calculates its area.
Explain the process of user input, variable declaration, and mathematical calculations in your
program.

Q11- Define abstract classes in Java and explain their purpose in object-oriented programming.

Q12- Discuss the concept of multithreading in Java. Explain the advantages and challenges of
multithreading.

Q13- Explain the AWT class hierarchy in Java and discuss the role of different container classes.

Q-14- Discuss the significance of constructors and methods in Java. Develop a Java class that
includes constructors with different parameters and methods that perform user-specific tasks.

Q-15 Write Java program that demonstrates method overloading, method overriding, and dynamic
method dispatch:

Q-16- Implement comprehensive Java application using AWT that demonstrates an interactive user
interface with buttons, labels, text fields, and menus.

Q-16. Compare and contrast Swing components and AWT components in Java. Implement a Swing-
based application that incorporates various Swing controls and containers to create an intuitive
and user-friendly graphical user interface.

Q-17- What is the Java Collections Framework?

Q19- comparison between Iterator and ListIterator in Java:

Q20- 5.Here's a simple Java program that demonstrates reading from and writing to a text file
using FileWriter and FileReader:

Q21- What is Serialization in Java?

Q22-connect a Java application to a database using JDBC (Java Database Connectivity), follow
these standard steps:
Q-23- Explain how synchronized blocks work. Provide a scenario where they are useful.

Q-24-What is complex time polymorphism and its importance? Use the compile time
polymorphism to show the example of object.

Q-25- Discuss method loading and overriding with example in Java.

Method Overloading:

Q26-Interface Inheritance and Polymorphism

Q27- Checked vs Unchecked Exceptions

Q-28: Event Delegation Model

Q-29- Applet Lifecycle

Q-30 Explain throws, throw, final, finally, finalize.

Q31- a Describe the different levels of access protection available in Java

ANSWER=--------------------------------------------------------------------------------------------------------------

Q-1. ) What is compile time polymorphism and its importance? Use the compile time
polymorphism in a Java program to create the objects.

✅ Q1: What is Compile Time Polymorphism and Its Importance?

Compile Time Polymorphism, also known as method overloading, occurs when multiple methods in
the same class have the same name but different parameters (type, number, or both). The method
that gets called is determined at compile time, based on the method signature.

✅ Importance of Compile Time Polymorphism

1. Improves Readability: Methods with the same name indicate similar functionality.
2. Code Reusability: You can use the same method name for different parameter types or
counts.

3. Performance: Since it’s resolved at compile time, it is faster than runtime polymorphism.

4. Simplicity: Makes class d..esign cleaner by avoiding multiple unrelated method names.

Example-

class Calculator {

int add(int a, int b) {

return a + b;--54

int add(int a, int b, int c) {

return a + b + c;

double add(double a, double b) {

 return a + b;

}public class Main {

public static void main(String[] args) {

Calculator calc = new Calculator();

System.out.println("Sum of 2 and 3: " + calc.add(2, 3));

System.out.println("Sum of 2, 3 and 4: " + calc.add(2, 3, 4));

System.out.println("Sum of 2.5 and 3.5: " + calc.add(2.5, 3.5));

Q-2= Discuss method loading and overriding with example in Java.

🔹 1. Method Overloading (Compile-Time Polymorphism)

Definition:
Method overloading occurs within the same class when multiple methods have the same name
but different parameter lists (number, type, or both).

✅ Characteristics:

 Happens at compile time

 Increases code readability and reusability

 No need for inheritance

✅ Example of Method Overloading:

class Printer {

void print(String text) {

System.out.println("Printing text: " + text);

} void print(int number) {

System.out.println("Printing number: " + number);

} void print(String text, int number) {

System.out.println("Printing: " + text + " and " + number);

public class OverloadExample {

public static void main(String[] args) {

 Printer printer = new Printer();

printer.print(123);

printer.print("Page", 5);

}
2-MARK

Q3- What is byte code in JVM?

Bytecode is an intermediate, platform-independent code generated by the Java compiler (javac)

from Java source code (.java files). It's essentially a set of instructions that the Java Virtual
Machine (JVM) can understand and execute. When you compile a Java program, it doesn't get
converted directly into machine code for a specific operating system and processor. Instead, it's
compiled into bytecode (.class files). This bytecode is then interpreted and executed by the JVM,
which acts as an abstraction layer between the Java program and the underlying
hardware/operating system. This "write once, run anywhere" capability is a core advantage of
Java, as the same bytecode can run on any platform for which a compatible JVM is available.

Q4- What do you know to be multithreading?

Multithreading is a programming concept that allows a program to execute multiple parts of its
code concurrently. In a multithreaded application, different threads (lightweight sub-processes)
can run independently within the same program, sharing the same memory space and resources.
This allows for better utilization of CPU resources, especially in modern multi-core processors. For
example, a web server might use multithreading to handle multiple client requests
simultaneously, or a graphical user interface (GUI) application might use one thread to handle
user input while another thread performs a time-consuming background task, keeping the UI
responsive. Java provides built-in support for multithreading through the Thread class and the
Runnable interface.

Q4- Compare Swing API and AWT API.

Feature AWT (Abstract Window Toolkit) Swing Nature Heavyweight components; relies on native
OS peers for rendering. Lightweight components; entirely written in Java, doesn't rely on native
peers. Look and Feel Platform-dependent; components look like native OS components.
Platform-independent; supports pluggable look and feel (e.g., Metal, Nimbus, Cross-Platform).
Functionality Provides basic GUI components; limited in functionality. Rich set of sophisticated
components (e.g., JTable, JTree, JSlider, JProgressBar). Performance Can be slower due to relying
on native calls. Generally faster as it renders its own components. Drawing Uses native OS
graphics for drawing. Uses Java2D API for drawing. Resources Consumes more system resources
due to native peers. Consumes fewer system resources. Examples Button, TextField, Frame, Panel
JButton, JTextField, JFrame, JPanel MVC Pattern Doesn't explicitly follow MVC (Model-View-
Controller) pattern. Explicitly follows MVC pattern, separating data from presentation.
Development Older GUI toolkit, less actively developed now. Newer and preferred GUI toolkit,
actively developed.

Q-5. Differentiate any character stream classes in Java.

Character stream classes in Java are primarily designed for handling text data (characters). They
deal with characters using Unicode, making them suitable for internationalized applications. The
base abstract classes for character streams are Reader and Writer. Reader: This is the abstract
superclass for all character input streams. Subclasses like FileReader, BufferedReader,
InputStreamReader, StringReader, etc., are used to read character data from various sources. For
example, FileReader reads characters from a file, and BufferedReader provides buffered reading
for efficiency. Writer: This is the abstract superclass for all character output streams. Subclasses
like FileWriter, BufferedWriter, OutputStreamWriter, PrintWriter, StringWriter, etc., are used to
write character data to various destinations. For example, FileWriter writes characters to a file, and
PrintWriter provides convenient methods for printing formatted text. The key difference from
byte streams is that character streams handle character encoding and decoding automatically,
converting between bytes and characters based on the default or specified character set. This
ensures that text data is handled correctly regardless of the underlying byte representation.

Q-6 Differentiate between String, StringBuffer, and StringBuilder.?

Feature String StringBuffer StringBuilder Mutability Immutable (cannot be changed after

creation). Mutable (can be changed after creation). Mutable (can be changed after creation).
Thread-Safety Thread-safe (as it's immutable, no synchronization issues). Thread-safe (methods
are synchronized). Not thread-safe (methods are not synchronized). Performance Less efficient
for repeated modifications (creates new objects). Slower than StringBuilder due to
synchronization overhead. Faster than StringBuffer (no synchronization overhead). Usage Ideal for
fixed, constant text. Preferred for multi-threaded environments where string modifications are
frequent. Preferred for single-threaded environments where string modifications are frequent.
Concatenation Uses + operator, concat() method (creates new String). Uses append(), insert()
methods (modifies existing object).

Q-7 Explain multi catch statement with an example.

The multi-catch statement (introduced in Java 7) allows you to catch multiple types of exceptions
in a single catch block, provided that the caught exceptions are not in an inheritance hierarchy
(i.e., one is not a subclass of another). This makes the code cleaner, more readable, and reduces
redundancy compared to having separate catch blocks for each exception type that perform the
same action.

Example:

import java.io.IOException;

import java.util.InputMismatchException;

import java.util.Scanner;

public class MultiCatchExample {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

try {

System.out.print("Enter an integer: ");

int num1 = scanner.nextInt();

System.out.print("Enter another integer: ");

int num2 = scanner.nextInt();

int result = num1 / num2;

System.out.println("Result: " + result);

 String text = null;

System.out.println(text.length()); // This will cause NullPointerException

} catch (InputMismatchException | ArithmeticException | NullPointerException e) {

// This single catch block handles multiple exception types

System.err.println("An error occurred: " + e.getMessage());

if (e instanceof InputMismatchException) {

System.err.println("Please enter valid integer input.");

} else if (e instanceof ArithmeticException) {

System.err.println("Cannot divide by zero.");

} else if (e instanceof NullPointerException) {

System.err.println("A null reference was accessed unexpectedly.");

} finally {

scanner.close();

Q-8.How can we make a thread to wait for specific time?

You can make a thread wait for a specific amount of time using the Thread.sleep() method. This
method causes the currently executing thread to cease execution for a specified number of
milliseconds (and optionally nanoseconds).

Syntax:

Thread.sleep(long milliseconds)

Thread.sleep(long milliseconds, int nanoseconds)

Example:

public void run() {

for (int i = 0; i < 5; i++) {

System.out.println(Thread.currentThread().getName() + ": " + i);

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

System.out.println(Thread.currentThread().getName() + " was interrupted.");

 Thread.currentThread().interrupt(); // Restore the interrupted status

public static void main(String[] args) {

SleepExample thread1 = new SleepExample();

thread1.setName("MyThread");

thread1.start();

System.out.println("Main thread continues...");

public void run() {

for (int i = 0; i < 5; i++) {

System.out.println(Thread.currentThread().getName() + ": " + i);

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

System.out.println(Thread.currentThread().getName() + " was interrupted.");

Thread.currentThread().interrupt(); // Restore the interrupted status

public static void main(String[] args) {

SleepExample thread1 = new SleepExample();

thread1.setName("MyThread");

thread1.start();

System.out.println("Main thread continues...");

Q-9- Differentiate between Panel and Frame with example.

Feature Panel Frame Purpose A container for other GUI components; cannot be a top-level
window. A top-level, independent window that can contain other components. Border Does not
have a title bar, borders, or menu bars by default. Has a title bar, borders, resize corners,
minimize/maximize/close buttons. Top-Level Not a top-level container; must be placed inside
another container (like a Frame or another Panel). A top-level container; can exist independently.
Visibility Not directly visible on its own; serves as a grouping mechanism. Directly visible as a
distinct window on the screen. Window Events Doesn't generate window events (like closing,
minimizing). Generates window events. Adding Components Components are added directly to
the Panel. Components are typically added to its content pane. Example JPanel (Swing), Panel
(AWT) JFrame (Swing), Frame (AWT)

Example (Swing):

import javax.swing.*;

import java.awt.*;

public class FrameAndPanelExample {

public static void main(String[] args) {

JFrame frame = new JFrame("My Application Window");

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

frame.setSize(400, 300);

frame.setLayout(new BorderLayout()); // Use a layout manager for the frame

JPanel panel1 = new JPanel();

panel1.setBackground(Color.LIGHT_GRAY);

panel1.setBorder(BorderFactory.createTitledBorder("Panel 1")); // Add a border for visibility

panel1.add(new JButton("Click Me!"));

panel1.add(new JTextField("Hello", 10));

JPanel panel2 = new JPanel();

panel2.setBackground(Color.ORANGE);

panel2.setBorder(BorderFactory.createTitledBorder("Panel 2"));

panel2.add(new JLabel("Enter Name:"));

panel2.add(new JTextField(15));

frame.add(panel1, BorderLayout.NORTH);

frame.add(panel2, BorderLayout.CENTER);

frame.setVisible(true);

}
Q 10- Write a Java program that takes user input for the radius of a circle and calculates its
area. Explain the process of user input, variable declaration, and mathematical calculations
in your program.

To calculate the area of a circle in Java, we follow a few steps: taking input from the user, declaring
necessary variables, and performing the mathematical calculation using the formula:

\text{Area} = \pi \times \text{radius}^2

Here is the complete Java program:

import java.util.Scanner;

public class CircleArea {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

System.out.print("Enter the radius of the circle: ");

double radius = scanner.nextDouble();

double area = Math.PI * radius * radius;

System.out.println("The area of the circle is: " + area);

Q11- Define abstract classes in Java and explain their purpose in object-oriented
programming.

An abstract class in Java is a class that cannot be instantiated on its own and may contain abstract
methods (methods without a body) as well as concrete methods (methods with implementations).
It is declared using the keyword abstract.

Syntax:

abstract class Animal {

abstract void sound(); // Abstract method

void eat() {

System.out.println("This animal eats food.");

Purpose in Object-Oriented Programming (OOP):

1. Abstraction:

Abstract classes allow you to define a common blueprint for related classes without providing
complete implementations. This encourages design flexibility and hides complex implementation
details.
2. Code Reusability:

Common code can be implemented in the abstract class and reused by all subclasses.

3. Polymorphism:

Abstract classes allow polymorphic behavior where base class references can point to subclass
objects and invoke overridden methods.

4. Partial Implementation:

It allows the developer to provide a partial implementation while leaving other methods to be
defined by subclasses.

Example:

abstract class Animal {

abstract void sound();

void sleep() {

System.out.println("Sleeping...");

class Dog extends Animal {

void sound() {

System.out.println("Dog barks");

public class Test {

public static void main(String[] args) {

Animal a = new Dog();

a.sound();

a.sleep();

Q12- Discuss the concept of multithreading in Java. Explain the advantages and challenges
of multithreading.

Multithreading in Java is a programming concept where multiple threads (smaller units of a

process) run concurrently, sharing the same memory space. Java provides built-in support for
multithreading, making it easy to perform multiple tasks simultaneously and improve
performance. Key Concepts: Thread: A lightweight subprocess, the smallest unit of processing.
Main Thread: The initial thread started by the JVM. Thread Class: Used to create threads by
extending it. Runnable Interface: Used to create threads by implementing it. Example- An abstract
class in Java is a class that cannot be instantiated on its own and may contain abstract methods
(methods without a body) as well as concrete methods (methods with implementations). It is
declared using the keyword abstract.

Syntax:

abstract class Animal {

abstract void sound(); // Abstract method

void eat() {
System.out.println("This animal eats food.");
}
}

Purpose in Object-Oriented Programming (OOP):

1. Abstraction:
Abstract classes allow you to define a common blueprint for related classes without providing
complete implementations. This encourages design flexibility and hides complex implementation
details.

2. Code Reusability:
Common code can be implemented in the abstract class and reused by all subclasses.

3. Polymorphism:
Abstract classes allow polymorphic behavior where base class references can point to subclass
objects and invoke overridden methods.

4. Partial Implementation:
It allows the developer to provide a partial implementation while leaving other methods to be
defined by subclasses.

Example:

abstract class Animal {

abstract void sound();
void sleep() {
System.out.println("Sleeping...");
}
}
class Dog extends Animal {
void sound() {
System.out.println("Dog barks");
}
}
public class Test {
public static void main(String[] args) {
 Animal a = new Dog();
a.sound();
a.sleep();
}
}
Advantages of Multithreading:
1. Improved Performance: Multiple threads run concurrently, enhancing speed.
2. Resource Sharing: Threads share the same memory space, reducing overhead.
3. Better CPU Utilization: Threads keep the CPU busy, maximizing use.
4. Responsive Applications: Helps in building responsive GUIs and real-time systems.
5. Asynchronous Behavior: Allows background tasks like file loading or network calls.
Challenges of Multithreading:
1. Complexity: Writing and managing multithreaded code can be complicated.
2. Synchronization Issues: Access to shared resources must be carefully synchronized to
avoid conflicts.
3. Deadlocks: Improper handling of locks can lead to deadlocks.
4. Debugging Difficulty: Errors are harder to trace due to concurrent executions.
5. Overhead: Excessive thread creation can lead to performance issues.
Q13- Explain the AWT class hierarchy in Java and discuss the role of different container
classes.

AWT (Abstract Window Toolkit) is a part of Java's standard library used for building graphical user
interfaces (GUIs). It is a platform-dependent API and relies on native code for rendering
components.

AWT Class Hierarchy Overview:

java.lang.Object

└── java.awt.Component

└── java.awt.Container

├── Panel

│ └── Applet

└── Window

├── Frame

└── Dialog

Key Classes:

1. Component: The abstract superclass for all GUI components (e.g., Button, Label,
TextField).
2. Container: A component that can contain other components (e.g., Panel, Frame).
3. Panel: A generic container that groups components together.
4. Applet: A special container for web-based applets (rarely used now).
5. Window: A top-level container without borders or menu bars.
6. Frame: A top-level window with a title and borders.
7. Dialog: A pop-up window for user interaction.
Role of Container Classes: Frame: Used to create main application windows. Panel: Helps organize
components inside containers. Dialog: Used for temporary messages or inputs. Layout Managers:
Containers use layout managers (like BorderLayout, FlowLayout) to manage the positioning of
components. (k) Write a Java program that demonstrates the use of adapter classes in event
handling.

Adapter classes in Java provide empty implementations of listener interfaces, allowing developers
to override only the methods they need.

Example using WindowAdapter:

import java.awt.*;

import java.awt.event.*;

public class AdapterExample {

public static void main(String[] args) {

Frame f = new Frame("Adapter Class Example");

f.setSize(300, 200);

f.setVisible(true);

f.addWindowListener(new WindowAdapter() {

public void windowClosing(WindowEvent e) {

f.dispose(); // Close the window

});

Q-14- Discuss the significance of constructors and methods in Java. Develop a Java class
that includes constructors with different parameters and methods that perform user-
specific tasks.

Significance of Constructors in Java:

Constructors are special methods used to initialize objects. When an object is created, the
constructor is called automatically. Constructors help in assigning initial values to instance
variables.

Default Constructor: Takes no parameters.

Parameterized Constructor: Accepts arguments to initialize the object with custom values.

Constructors do not have a return type, not even void, and their name must match the class name.

Significance of Methods in Java:

Methods define the behavior of objects. They are blocks of code that perform specific tasks.
Methods help:

Encapsulate logic.

Reuse code.

Organize complex programs into manageable sections.

Java Class Example:

public class UserProfile {

String name;

int age;

public UserProfile() {

name = "Unknown";

age = 0;

public UserProfile(String userName, int userAge) {

name = userName;

age = userAge;

public void displayProfile() {

System.out.println("Name: " + name);

System.out.println("Age: " + age);

public void checkAdult() {

if (age >= 18) {

System.out.println(name + " is an adult.");

} else {

System.out.println(name + " is not an adult.");

}
 public static void main(String[] args) {

UserProfile user1 = new UserProfile();

user1.displayProfile();

user1.checkAdult();

System.out.println("----------");

UserProfile user2 = new UserProfile("Alice", 22);

user2.displayProfile();

user2.checkAdult();

Q-15 Write Java program that demonstrates method overloading, method overriding, and
dynamic method dispatch:

class Animal {

void sound() {

System.out.println("Animal makes a sound");

void info() {

System.out.println("This is an animal.");

void info(String type) {

System.out.println("This is a " + type + ".");

class Dog extends Animal {

void sound() {

System.out.println("Dog barks");

void info(String type, int age) {

System.out.println("This is a " + type + " and it is " + age + " years old.");

}
}

public class Main {

public static void main(String[] args) {

Animal a = new Animal();

a.info();

a.info("Mammal");

Animal ref; // superclass reference

Dog d = new Dog(); // subclass object

ref = d; // dynamic dispatch

ref.sound(); // calls Dog's overridden method at runtime

d.info("Dog", 5);

Q-16- Implement comprehensive Java application using AWT that demonstrates an

interactive user interface with buttons, labels, text fields, and menus.

Java Code Using AWT Components

import java.awt.*;

import java.awt.event.*;

public class AWTInterfaceExample extends Frame implements ActionListener {

TextField textField;

Label label;

Button button;

MenuBar menuBar;

Menu menu;

MenuItem menuItemExit;

public AWTInterfaceExample() {

setTitle("AWT UI Example");

label = new Label("Enter your name:");

label.setBounds(50, 100, 150, 20);

 add(label);

textField = new TextField();

textField.setBounds(200, 100, 150, 20);

add(textField);

button = new Button("Click Me");

button.setBounds(200, 150, 80, 30);

button.addActionListener(this);

add(button);

menuBar = new MenuBar();

menu = new Menu("File");

menuItemExit = new MenuItem("Exit");

menuItemExit.addActionListener(e -> System.exit(0));

menu.add(menuItemExit);

menuBar.add(menu);

setMenuBar(menuBar);

setSize(400, 300);

setLayout(null);

setVisible(true);

addWindowListener(new WindowAdapter() {

public void windowClosing(WindowEvent we) {

dispose();

});

public void actionPerformed(ActionEvent e) {

label.setText("Hello, " + textField.getText() + "!");

public static void main(String[] args) {

new AWTInterfaceExample();

}
Q-16. Compare and contrast Swing components and AWT components in Java. Implement a
Swing-based application that incorporates various Swing controls and containers to create
an intuitive and user-friendly graphical user interface.

1. Comparison Between Swing and AWT Components

Java provides two primary libraries for creating Graphical User Interfaces (GUIs): AWT (Abstract
Window Toolkit) and Swing. While both are used for developing windows-based applications,
they have distinct differences in architecture, capabilities, and usage. 1.1 AWT (Abstract Window
Toolkit) AWT is Java’s original platform-dependent GUI toolkit that uses the native GUI
components of the operating system. It provides basic building blocks such as buttons, labels,
text fields, etc. Heavyweight Components: AWT relies on native code, meaning each AWT
component is linked to a native GUI component (e.g., a Button in AWT corresponds to an OS
button). Platform Dependent: GUI appearance can vary across operating systems. Limited Set of
Components: Fewer GUI components and layout options. Performance: Slightly faster because it
uses native OS resources. Customization: Limited due to native dependency. 1.2 Swing Swing is a
part of the Java Foundation Classes (JFC) and is built on top of AWT. It provides a rich set of GUI
components and is entirely written in Java. Lightweight Components: Do not depend on the
native GUI; instead, they are rendered by Java itself. Platform Independent: Swing applications
have a consistent look and feel across all platforms. Rich Set of Components: Offers advanced
components such as tables (JTable), trees (JTree), and tabbed panes (JTabbedPane).
Customizable: Developers can change appearance using "Look and Feel" settings. Extensible:
Easier to extend and customize components. 1.3 Comparison Table ---
2. Swing-Based Application Implementation
Below is a simple Java application that uses Swing components and containers to create an
intuitive and user-friendly GUI.

import javax.swing.*;

import java.awt.event.*;

public class SwingFormApp {

public static void main(String[] args) {

JFrame frame = new JFrame("User Registration Form");

frame.setSize(400, 300);

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

JPanel panel = new JPanel();

frame.add(panel);

placeComponents(panel);

frame.setVisible(true);

private static void placeComponents(JPanel panel) {

panel.setLayout(null);

JLabel nameLabel = new JLabel("Name:");

nameLabel.setBounds(10, 20, 80, 25);

panel.add(nameLabel);

JTextField nameText = new JTextField(20);

nameText.setBounds(150, 20, 165, 25);

panel.add(nameText);

JLabel emailLabel = new JLabel("Email:");

emailLabel.setBounds(10, 50, 80, 25);

panel.add(emailLabel);

JTextField emailText = new JTextField(20);

emailText.setBounds(150, 50, 165, 25);

panel.add(emailText);

JLabel genderLabel = new JLabel("Gender:");

genderLabel.setBounds(10, 80, 80, 25);

panel.add(genderLabel);

JRadioButton male = new JRadioButton("Male");

male.setBounds(150, 80, 70, 25);

panel.add(male);

JRadioButton female = new JRadioButton("Female");

female.setBounds(230, 80, 100, 25);

panel.add(female);

ButtonGroup genderGroup = new ButtonGroup();

genderGroup.add(male);

genderGroup.add(female);

JButton submitButton = new JButton("Submit");

submitButton.setBounds(150, 120, 100, 25);

panel.add(submitButton);

submitButton.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

String name = nameText.getText();

String email = emailText.getText();

 String gender = male.isSelected() ? "Male" : female.isSelected() ? "Female" :
"Unspecified";

JOptionPane.showMessageDialog(panel,

"Name: " + name + "\nEmail: " + email + "\nGender: " + gender,

"User Details",

JOptionPane.INFORMATION_MESSAGE);

});

Q-17- What is the Java Collections Framework?

The Java Collections Framework (JCF) is a unified architecture for representing and manipulating
collections of objects in Java. It provides a set of interfaces (like List, Set, Map) and classes (like
ArrayList, LinkedList, HashSet, HashMap) to store and manage data efficiently.

he Java Collections Framework (JCF) is a unified architecture for representing and manipulating
collections of objects in Java. It provides a set of interfaces (like List, Set, Map) and classes (like
ArrayList, LinkedList, HashSet, HashMap) to store and manage data efficiently. Key benefits of JCF:
Reduces programming effort with reusable data structures. Improves performance through
optimized implementations. Provides interoperability between different data structures. ---
1. Differences between ArrayList, LinkedList, HashSet, and HashMap:
Feature ArrayList LinkedList HashSet HashMap Type List (ordered collection) List (ordered
collection) Set (unordered, unique elements) Map (key-value pairs) Duplicates Allowed Allowed
Not allowed Keys: Not allowed, Values: Allowed Order Maintains insertion order Maintains
insertion order No guaranteed order No guaranteed order Access Time Fast (index-based, O(1))
Slow (O(n)) Fast (O(1) average, O(n) worst) Fast (O(1) average, O(n) worst) Insert/Delete Slower
(shifting needed) Faster (no shifting) Fast (based on hash table) Fast (based on hash table)
Underlying Data Structure Dynamic array Doubly linked list Hash table Hash table Use Case Best
for random access & iteration Best for frequent insert/delete Best for unique elements Best for
key-value storage ---

Examples:

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

list.add("A");

list.add("B");

LinkedList<String> linkedList = new LinkedList<>();

linkedList.add("X");

linkedList.add("Y");

HashSet<Integer> set = new HashSet<>();

set.add(10);

set.add(20);

HashMap<Integer, String> map = new HashMap<>();

map.put(1, "Apple");

map.put(2, "Banana");

Q-18- 3 use of Generics in Java?

Generics enable types (classes and interfaces) to be parameters when defining classes, interfaces,
and methods. They allow you to write type-safe and reusable code.

Why Generics Are Important:

1. Type Safety:
Generics ensure that you only use the correct type of objects. This avoids runtime
ClassCastException.
2. Code Reusability:
One generic class/method can work with different data types.
3. Elimination of Type Casting:
You don't need to cast objects when retrieving them.
4. Compile-time Checking:Errors are caught early during compilation instead of at
runtime.
Example: Generic Class
class Box<T> {
private T value;

public void set(T value) {

this.value = value;
}

public T get() {
return value;
}
}
public class GenericExample {
public static void main(String[] args) {
Box<Integer> intBox = new Box<>();
intBox.set(100);
System.out.println("Integer Value: " + intBox.get());
Box<String> strBox = new Box<>();
strBox.set("Hello Generics");
System.out.println("String Value: " + strBox.get());
}
}
Q19- comparison between Iterator and ListIterator in Java:
Feature Iterator ListIterator

Interface Location In java.util package In java.util package

Applicable To Works with all Collection types (List, Set, etc.) Works only with
List implementations (e.g., ArrayList)
Traversal Direction Only forward Both forward and backward
Methods for Traversal hasNext(), next() hasNext(), next(),
hasPrevious(), previous()
Add Elements Not supported add() method is available
Replace Elements Not supported set() method is available
Remove Elements remove() method is available remove() method is
available
Get Index Not available nextIndex(), previousIndex() available
Efficiency Lightweight, best for one-direction traversal More powerful,
but slightly heavier
---
Example of Iterator:

Iterator<String> it = list.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}

Example of ListIterator:

ListIterator<String> lit = list.listIterator();

while (lit.hasNext()) {
System.out.println("Forward: " + lit.next());
}
while (lit.hasPrevious()) {
System.out.println("Backward: " + lit.previous());
}

Q20- 5.Here's a simple Java program that demonstrates reading from and writing to
a text file using FileWriter and FileReader:
Java Program: Read and Write using FileReader and FileWriter

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class FileReadWriteExample {
public static void main(String[] args) {
String filename = "example.txt";
try (FileWriter writer = new FileWriter(filename)) {
writer.write("Hello, this is a sample text file.\n");
writer.write("It demonstrates FileReader and FileWriter in Java.");
System.out.println("File written successfully.");
} catch (IOException e) {
System.out.println("Error while writing to file: " + e.getMessage());
}
try (FileReader reader = new FileReader(filename)) {
 int character;
System.out.println("File content:");
while ((character = reader.read()) != -1) {
System.out.print((char) character);
}
} catch (IOException e) {
System.out.println("Error while reading from file: " + e.getMessage());
}
}
}
Q21- What is Serialization in Java?
Serialization in Java is the process of converting an object into a byte stream so it
can be saved to a file or transferred over a network.
Deserialization is the reverse process—converting the byte stream back into an
object.
Why Use Serialization?
To persist object state (e.g., saving data to a file).
To transfer objects between JVMs (e.g., in RMI or network communication).

Java Program: Serialize and Deserialize an Object

import java.io.*;
class Student implements Serializable {
private static final long serialVersionUID = 1L;
String name;
int age;
Student(String name, int age) {
this.name = name;
this.age = age;
}

void display() {
System.out.println("Name: " + name + ", Age: " + age);
}
}

public class SerializationExample {

public static void main(String[] args) {
Student s1 = new Student("Ravi", 22);
String filename = "student.ser";
try (FileOutputStream fos = new FileOutputStream(filename);
ObjectOutputStream oos = new ObjectOutputStream(fos)) {
oos.writeObject(s1);
System.out.println("Object serialized successfully.");
} catch (IOException e) {
e.printStackTrace();
}
try (FileInputStream fis = new FileInputStream(filename);
ObjectInputStream ois = new ObjectInputStream(fis)) {
 Student s2 = (Student) ois.readObject();
System.out.println("Object deserialized successfully.");
s2.display();
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}

Q22-connect a Java application to a database using JDBC (Java Database Connectivity),

follow these standard steps:
1. Serializable Interface
Purpose: Default serialization mechanism.
Package: java.io.Serializable
Methods: It is a marker interface—it has no methods.
Behavior: The JVM automatically handles the serialization/deserialization process.
Control: Limited control over what and how data is serialized.
Customization: Can use transient keyword to exclude fields from serialization.

Example:
class Student implements Serializable {
int id;
String name;
}

2. Externalizable Interface
Purpose: Gives full control over serialization.
Package: java.io.Externalizable
Methods: You must implement two methods:
writeExternal(ObjectOutput out)
readExternal
To connect a Java application to a database using JDBC (Java Database Connectivity),
follow these standard steps:

1. Load the JDBC Driver

This step registers the JDBC driver with the driver manager.
Class.forName("com.mysql.cj.jdbc.Driver"); // For MySQL
> Modern JDBC drivers may auto-register, but this is still good practice.

2. Establish a Connection
Use DriverManager.getConnection() with the URL, username, and password.
Connection conn = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/mydatabase", "root", "password");

3. Create a Statement or PreparedStatement

This object is used to send SQL queries to the database.
Statement stmt = conn.createStatement();
// OR
PreparedStatement pstmt = conn.prepareStatement("SELECT * FROM users WHERE id
= ?");

4. Execute the Query

For SELECT queries, use executeQuery().
For INSERT, UPDATE, or DELETE, use executeUpdate().
ResultSet rs = stmt.executeQuery("SELECT * FROM users");
// OR
int rowsAffected = stmt.executeUpdate("UPDATE users SET name='John' WHERE
id=1");

5. Process the Results

Loop through the ResultSet for SELECT queries.
while (rs.next()) {
System.out.println(rs.getInt("id") + ": " + rs.getString("name"));
}

6. Close the Resources

Always close ResultSet, Statement, and Connection to prevent memory leaks.
rs.close();
stmt.close();
conn.close();

Complete Example:

import java.sql.*;
public class JDBCDemo {
public static void main(String[] args) {
try {
Class.forName("com.mysql.cj.jdbc.Driver");
Connection conn = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/testdb", "root", "password");
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM students");
while (rs.next()) {
System.out.println(rs.getInt("id") + ": " + rs.getString("name"));
}
rs.close();
stmt.close();
conn.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
Q-23- Explain how synchronized blocks work. Provide a scenario where they are useful.

What is a synchronized block? A synchronized block in Java is a block of code that is

synchronized on a specified object. It ensures that only one thread at a time can execute the
block of code for the given object lock. --- Syntax: synchronized (lockObject) { // critical section
code } lockObject is the object whose monitor (lock) is used to control access. Only one thread
can hold the lock at a time; others wait. --- Why use synchronized blocks? To prevent race
conditions and ensure thread safety when multiple threads access shared mutable data. More
fine-grained control compared to synchronized methods, as you can synchronize only the critical
part of code. --- Example Scenario: Bank Account Withdrawal Multiple threads trying to withdraw
money from the same account can cause inconsistent balance if not synchronized.
public class BankAccount {
private int balance = 1000;
public void withdraw(int amount) {
synchronized (this) {
if (balance >= amount) {
System.out.println(Thread.currentThread().getName() + " is withdrawing " +
amount);
balance -= amount;
System.out.println("Remaining balance: " + balance);
} else {
System.out.println("Insufficient balance for " +
Thread.currentThread().getName());
}
}
}
}
Q-24-What is complex time polymorphism and its importance? Use the compile time
polymorphism to show the example of object.
Complex Time Polymorphism (Runtime Polymorphism / Dynamic Method Dispatch):
Complex time polymorphism, more commonly known as runtime polymorphism or
dynamic method dispatch, is a fundamental concept in Object-Oriented Programming
(OOP) where the method call resolution (determining which specific method
implementation to execute) happens at runtime rather than at compile time. This is
achieved primarily through method overriding. When a superclass reference variable
holds an object of a subclass, and a method is called on that reference variable, the
actual method executed is determined by the type of the object being referred to, not
the type of the reference variable.

Importance:
Flexibility and Extensibility: It allows for writing highly flexible and extensible code.
New subclasses can be added without modifying existing code that uses the superclass
reference.
Decoupling: It decouples the code that calls a method from the specific implementation
of that method. The calling code only needs to know about the superclass interface, not
the specific subclass details.
Code Reusability: Common behavior can be defined in a superclass, and specific
implementations can be provided by subclasses, promoting code reuse.
Achieving Abstraction: It enables abstraction by allowing a general interface (defined by
the superclass) to be used for various specific implementations.
Compile Time Polymorphism (Method Overloading / Static Method Dispatch):
Compile time polymorphism, or static method dispatch, occurs when the method call
resolution happens at compile time. This is primarily achieved through method
overloading, where multiple methods in the same class have the same name but
different parameters (different number, type, or order of arguments). The compiler
determines which overloaded method to call based on the method signature (name +
parameters) at compile time.

Example of Object in Compile-Time Polymorphism (Method Overloading):

class Calculator {
public int add(int a, int b) {
return a + b;
}
public int add(int a, int b, int c) {
return a + b + c;
}
public double add(double a, double b) {
return a + b;
}
}
Q-25- Discuss method loading and overriding with example in Java.
Method Overloading:

Method overloading is a feature in Java that allows a class to have multiple methods
with the same name, provided they have different method signatures. The method
signature includes the method name and the number, type, and order of its parameters.
The return type alone is not sufficient to distinguish overloaded methods. Overloading
is a form of compile-time polymorphism (static polymorphism).

Rules for Method Overloading:

Methods must have the same name.

Methods must have different parameter lists (different number of arguments, different
data types of arguments, or different order of arguments).
Return type and access modifiers can be the same or different.
Example of Method Overloading:
class Printer {
public void print(int num) {
System.out.println("Printing integer: " + num);
}
public void print(String text) {
System.out.println("Printing string: " + text);
}
public void print(int num, String text) {
System.out.println("Printing integer and string: " + num + ", " + text);
}
}
public class OverloadingExample {
public static void main(String[] args) {
Printer printer = new Printer();
 printer.print(10);
printer.print("Hello Java!");
printer.print(20, "Overloaded");
}
}
Q26-Interface Inheritance and Polymorphism
public interface Shape {
void draw();
}
public class Circle implements Shape {
public void draw() {
System.out.println("Drawing a circle");
}
}
public class Rectangle implements Shape {
public void draw() {
System.out.println("Drawing a rectangle");
}
}
public class Main {
public static void main(String[] args) {
Shape shape1 = new Circle();
Shape shape2 = new Rectangle();
shape1.draw();
shape2.draw();
}
}
Q27- Checked vs Unchecked Exceptions

Checked exceptions are exceptions that are checked at compile-time, while unchecked
exceptions are exceptions that are not checked at compile-time.
// Checked exception
public class Main {
public static void main(String[] args) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
System.out.println("Thread interrupted");
}
}
}
public class Main {
public static void main(String[] args) {
int[] array = new int[5];
System.out.println(array[10]); // Throws ArrayIndexOutOfBoundsException
}
}
Q-28: Event Delegation Model
The Event Delegation Model is a mechanism in Java where events are generated by
components and delegated to listener objects that handle the events. Here's a practical
example:
import java.awt.*;
import java.awt.event.*;
public class EventDelegationExample {
public static void main(String[] args) {
Frame frame = new Frame("Event Delegation Example");
Button button = new Button("Click Me");
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
System.out.println("Button clicked!");
}
};
frame.add(button);
frame.setSize(300, 200);
frame.setVisible(true);
Q-29- Applet Lifecycle
Adapter classes in Java are used to simplify event handling by providing a default
implementation of listener interfaces. They help by allowing developers to override
only the methods they need, rather than implementing all methods of the listener
interface.
The lifecycle of an applet includes the following stages:
1. *Initialization*: The applet is initialized by calling the `init()` method.
2. *Start*: The applet starts executing by calling the `start()` method.
3. *Paint*: The applet is painted or repainted by calling the `paint()` method.
4. *Stop*: The applet stops executing by calling the `stop()` method.
5. *Destroy*: The applet is destroyed by calling the `destroy()` method.
Here's a simple diagram:
+---------------+
| Initialize |
| (init()) |
+---------------+
|
|
v
+---------------+
| Start |
| (start()) |
+---------------+
|
|
v
+---------------+
| Paint |
| (paint()) |
+---------------+
|
|
 v
+---------------+
| Stop |
| (stop()) |
+---------------+
|
|
v
+---------------+
| Destroy |
| (destroy()) |
+---------------+

Q-30 Explain throws, throw, final, finally, finalize.

These five keywords/concepts are often confused due to similar spellings but serve
very distinct purposes in Java, primarily related to exception handling and object
lifecycle.
throw (Keyword):
Purpose: Used to explicitly throw an exception object from a method or any block of
code.
Usage: You create an instance of an exception class (which must be a subclass of
Throwable) and then use throw to signal that an exceptional condition has occurred.
throw is followed by an instance of Throwable.
Context: Inside a method where an error condition is detected.
Example:
public void checkAge(int age) {
if (age < 0) {
throw new IllegalArgumentException("Age cannot be negative.");
}
System.out.println("Age is valid: " + age);
}
throws (Keyword):

Purpose: Used in a method signature to declare that a method might throw one or more
checked exceptions. It informs the calling code that it needs to handle these potential
exceptions.
Usage: Followed by a comma-separated list of exception classes.
throws does not cause an exception to be thrown; it merely indicates that the method
might throw it. The actual throwing still happens using the throw keyword within the
method's body.
Context: In the method signature.
Example:
import java.io.IOException;
import java.io.FileReader;
public class FileProcessor {
public void readFile(String filePath) throws IOException {
FileReader reader = new FileReader(filePath); // This line can throw
FileNotFoundException (an IOException)
reader.close();
 }
public static void main(String[] args) {
FileProcessor processor = new FileProcessor();
try {
processor.readFile("non_existent.txt"); // Caller must handle the declared
IOException
} catch (IOException e) {
System.err.println("Error reading file: " + e.getMessage());
}
}
}
Q31- a Describe the different levels of access protection available in Java:
In Java, access protection (also called access control or access modifiers) helps manage visibility
and accessibility of classes, methods, and variables. Java supports four types of access levels:
1. Private Access Modifier:
Declared using the private keyword. Members marked private are accessible only within the same
class. They are not visible to subclasses or classes in the same package. Example: private int data;
2. Default (Package-Private) Access Modifier:
When no access modifier is specified, Java applies default access. Default access allows class
members to be accessible within the same package only. This is also known as package-private
access. Example: int data; // default access
3. Protected Access Modifier:
Declared using the protected keyword. Accessible within the same package and also in
subclasses located in different packages. Useful when working with inheritance. Example:
protected int data;
4. Public Access Modifier:
Declared using the public keyword. Members marked public are accessible from any other class
in the Java project, regardless of package. Example: public int data; These modifiers provide
encapsulation and allow a programmer to control how the internal data of a class is accessed and
modified from other classes. b) Explanation and Code: Create a base class called Shape and a
subclass Rectangle using method overriding In Java, inheritance allows a class to inherit
properties and behavior (methods) from another class. The base class (or parent class) provides
basic functionality, and the subclass (or child class) can enhance or modify it using method
overriding. Explanation: Create a base class Shape with two methods: getxyvalue() – to accept
coordinates. showxyvalue() – to display the coordinates. Create a subclass Rectangle that extends
Shape. Add an extra method to accept and display the length and breadth. Override the method
showxyvalue() to include additional details.
// Base class Shape
class Shape {
int x, y;

// Method to accept coordinates

void getxyvalue(int a, int b) {
x = a;
y = b;
}

// Method to display coordinates

void showxyvalue() {
 System.out.println("Coordinates: X = " + x + ", Y = " + y);
}
}

// Subclass Rectangle extending Shape

class Rectangle extends Shape {
int length, breadth;

// Method to set dimensions

void getLengthBreadth(int l, int b) {
length = l;
breadth = b;
}

// Overriding method to display coordinates and dimensions

void showxyvalue() {
// Call the base class method to show coordinates
super.showxyvalue();
// Display rectangle dimensions
System.out.println("Rectangle dimensions: Length = " + length + ", Breadth = " +
breadth);
}
Q-32-Explain how exception handling mechanism can be used in a Java program.
Exception Handling in Java is a mechanism used to handle runtime errors, ensuring normal flow
of program execution. It is achieved using try, catch, throw, throws, and finally blocks. Purpose of
Exception Handling: Prevents program termination when an error occurs. Helps maintain the flow
of execution. Enhances code clarity and robustness. Syntax and Keywords: try: Contains code that
might throw an exception. catch: Handles the exception. finally: Executes code after try/catch,
regardless of exception. throw: Used to explicitly throw an exception. throws: Declares exceptions
in method signature.
Example:

public class ExceptionExample {

public static void main(String[] args) {
int a = 10, b = 0;
try {
int result = a / b;
System.out.println("Result: " + result);
} catch (ArithmeticException e) {
System.out.println("Exception caught: Division by zero is not allowed.");
} finally {
System.out.println("This block always executes.");
}
}
}

Output:

Exception caught: Division by zero is not allowed.

Q33- Write a Java program to implement Runnable class to create a Thread.
In Java, to create a thread using the Runnable interface, you must:
Implement the Runnable interface.
Define the run() method.
Pass the instance to a Thread object.
Java Program

class MyRunnable implements Runnable {

public void run() {
System.out.println("Thread is running using Runnable interface: " +
Thread.currentThread().getName());
}
}
public class RunnableExample {
public static void main(String[] args) {
MyRunnable runnable = new MyRunnable();
Thread t1 = new Thread(runnable);
Thread t2 = new Thread(runnable);

t1.start();
t2.start();
}
}

Explanation:
MyRunnable implements Runnable.
Thread objects are created by passing the Runnable instance.
start() runs the run() method in a separate thread.
Q-34 Write a Java program to display the different car names using list object.
Java provides the List interface in the java.util package. We can use ArrayList to store
and display car names.
Java Program:

import java.util.*;
public class CarListExample {
public static void main(String[] args) {
List<String> cars = new ArrayList<>();
cars.add("Toyota");
cars.add("Honda");
cars.add("Ford");
cars.add("BMW");
cars.add("Tesla");
System.out.println("List of Car Names:");
for (String car : cars) {
System.out.println(car);
}
}
}
Output:

List of Car Names:

Toyota
Honda
Ford
BMW
Tesla

EXPLANATION
ArrayList is used to store car names.

A for-each loop is used to display each name.

Q=35-Write a Java program to display the month names by JList and display the
Days by JComboBox.]

Explanation:

Swing provides JList and JComboBox for displaying lists and dropdowns. JList is used
for displaying month names, and JComboBox for displaying days.

Java Swing Program:

import javax.swing.*;
import java.awt.*;

public class DateDisplay extends JFrame {

public DateDisplay() {
setTitle("Month and Day Display");
setSize(300, 250);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setLayout(new FlowLayout());
String[] months = { "January", "February", "March", "April", "May", "June",
"July", "August", "September", "October", "November", "December" };
JList<String> monthList = new JList<>(months);
monthList.setVisibleRowCount(5);
JScrollPane monthScroll = new JScrollPane(monthList);

// JComboBox for days

String[] days = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday",
"Friday", "Saturday" };
JComboBox<String> dayComboBox = new JComboBox<>(days);

add(new JLabel("Select a Month:"));

add(monthScroll);
add(new JLabel("Select a Day:"));
add(dayComboBox);

setVisible(true);
 }

public static void main(String[] args) {

new DateDisplay();
}
}
Q-36- Explain the different types of inheritance with schematic diagrams and
examples. Write down a Java program that uses interface to obtain multiple
inheritance.
Types of Inheritance in Java:

1. Single Inheritance:
One subclass inherits from one superclass.
Diagram:
A
|
B

2. Multilevel Inheritance:
A class is derived from a class, which is also derived from another class.
Diagram:

A
|
B
|
C
3. Hierarchical Inheritance:
Multiple classes inherit from a single parent class.
Diagram:

A
/\
B C

5. Multiple Inheritance (using Interfaces):

6. A class implements multiple interfaces.
Diagram:
Interface A Interface B
\ /
\ /
Class C