Q1. Explain the features of Java that make it platform-independent and robust.

Platform Independence:
Java's platform independence is one of its most celebrated features. It means that a
Java program written once can run on any operating system (Windows, macOS, Linux,
etc.) that has a Java Runtime Environment (JRE). This is achieved through the
following mechanisms:
1. Bytecode:
○ When you compile a Java source file (.java), the Java compiler doesn't
produce machine code directly. Instead, it generates an intermediate code
called bytecode (.class).
○ Bytecode is a platform-independent set of instructions that the Java Virtual
Machine (JVM) understands.
2. Java Virtual Machine (JVM):
○ The JVM is a software layer that sits between the Java bytecode and the
underlying operating system.
○ Each operating system has its own implementation of the JVM.
○ When you run a Java program, the JVM interprets the bytecode and
translates it into machine code that the specific operating system can
execute.
○ This "write once, run anywhere" principle is the core of Java's portability.
Robustness:
Java is designed to be robust, meaning it's designed to handle errors and prevent
crashes. Several features contribute to this:
1. Strongly Typed Language:
○ Java is a strongly typed language, which means that every variable and
expression has a type that is known at compile time.
○ This helps catch type-related errors early in the development process,
reducing the likelihood of runtime errors.
2. Garbage Collection:
○ Java has automatic garbage collection, which means that the JVM
automatically manages memory allocation and deallocation.
○ Developers don't have to manually allocate or free memory, which
eliminates many common memory-related errors, such as memory leaks
and dangling pointers.
3. Exception Handling:
○ Java provides a robust exception handling mechanism that allows
developers to handle runtime errors gracefully.
○ Exceptions are objects that represent errors, and the try-catch-finally
blocks allow developers to catch and handle these errors, preventing
program crashes.
4. Security Features:
○ Java has built-in security features, such as bytecode verification and a
security manager, that help protect against malicious code.
○ The JVM verifies the bytecode before executing it, ensuring that it is
valid and doesn't violate security constraints.
5. Comprehensive Standard Library:
○ Java has a rich set of standard libraries that provide many pre-built
classes and methods for common tasks.
○ This reduces the need for developers to write low-level code, which
can be error-prone.
Q2. List and briefly describe the primitive data types available in Java. Explain
the difference between primitive and reference data types.
Primitive Data Types:
Java has eight primitive data types:
1. byte:
○ 8-bit signed integer.
○ Range: -128 to 127.
○ Used for small integer values.
2. short:
○ 16-bit signed integer.
○ Range: -32,768 to 32,767.
○ Used for integer values that don't require the full range of int.
3. int:
○ 32-bit signed integer.
○ Range: -2,147,483,648 to 2,147,483,647.
○ The most commonly used integer type.
4. long:
○ 64-bit signed integer.
○ Range: -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807.
○ Used for very large integer values.
5. float:
○ 32-bit single-precision floating-point number.
○ Used for decimal numbers.
6. double:
○ 64-bit double-precision floating-point number.
○ Used for decimal numbers with greater precision.
7. char:
○ 16-bit Unicode character.
○ Represents a single character.
8. boolean:
○ Represents a boolean value (true or false).
Primitive vs. Reference Data Types:
● Primitive Data Types:
○ Store the actual value in the memory location assigned to the variable.
○ Have a fixed size.
○ Are not objects.
○ Examples: int, double, boolean.
● Reference Data Types:
○ Store the memory address (reference) of the object in the memory
location assigned to the variable.
○ Their size can vary.
○ Are objects.
○ Examples: String, arrays, user-defined classes.
○ When you assign a reference variable to another reference variable,
you are copying the reference, not the object itself.
Q3. Write a Java program that takes two integer inputs from the user and
performs arithmetic operations (addition, subtraction, multiplication, and
division). Display the results.

import java.util.Scanner;

public class ArithmeticOperations {

public static void main(String[] args) {
Scanner scanner = new
Scanner(System.in);

System.out.print("Enter the first integer:

"); int num1 = scanner.nextInt();

System.out.print("Enter the second integer:

"); int num2 = scanner.nextInt();

System.out.println("Addition: " + (num1 + num2));

System.out.println("Subtraction: " + (num1 -
num2)); System.out.println("Multiplication: " +
(num1 * num2)); if (num2 != 0) {
System.out.println("Division: " + ((double) num1 /
num2));
} else {
System.out.println("Division by zero is not
allowed.");
}

scanner.close();
}
}
Q4. Write a Java program to calculate the area of a circle, taking the radius as
input from the user.
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);
scanner.close();
}
}
Q5. Analyze the differences between while and do-while loops in Java. Provide
examples to illustrate scenarios where each loop type is more appropriate.
while Loop:
● The while loop checks the condition before executing the loop body.

● If the condition is false initially, the loop body will not execute at all.
do-while Loop:
● The do-while loop checks the condition after executing the loop body.
● This guarantees that the loop body will execute at least once, even if the condition
is false initially.
Examples:
● while loop example
int count = 5;
while (count > 0)
{
System.out.println("Count: " +
count); count--;
}
This loop will print the counts from 5 to 1. If count was initialized to 0, nothing
would print.
● do-while loop example
Scanner scanner = new
Scanner(System.in); int number;
do {
System.out.print("Enter a positive number:
"); number = scanner.nextInt();
} while (number <= 0);
System.out.println("You entered: " +
number); scanner.close();
This loop will prompt the user to enter a positive number until they do so, ensuring
that
the prompt is displayed at least once.
Q6. Design a Java program that takes an integer input from the user and
determines if it is a prime number. Use appropriate control flow statements to
implement the logic. import java.util.Scanner;

public class PrimeNumber {

public static void main(String[] args) {
Scanner scanner = new
Scanner(System.in);

System.out.print("Enter an integer:
"); int number = scanner.nextInt();

if (number <= 1) {
System.out.println(number + " is not a prime
number.");
} else {
boolean isPrime = true;
for (int i = 2; i <= Math.sqrt(number);
i++) { if (number % i == 0) {
isPrime = false;
break;
}
}
if (isPrime) {
System.out.println(number + " is a prime number.");
} else {
System.out.println(number + " is not a prime
number.")
 }
}
scanner.close();
}
}
Explanation:
1. Input: The program takes an integer input from the user.
2. Base Cases: Numbers less than or equal to 1 are not prime.
3. Iteration: The program iterates from 2 up to the square root of the number.
4. Divisibility Check: In each iteration, it checks if the number is divisible by i. If
it is, the number is not prime, and the loop breaks.
5. Result: If the loop completes without finding any divisors, the number is prime.
Q7. Differentiate between == and .equals() in Java with suitable examples.
== Operator:
● Compares the memory addresses of two objects.
● For primitive data types, it compares the actual values.
● For reference data types, it checks if two references point to the same object in
memory.

.equals() Method:
● Compares the contents of two objects.
● The default implementation of .equals() in the Object class is the same as ==.
● Classes like String, Integer, and others override the .equals() method to
compare the actual values of the objects.
Examples:
public class EqualityComparison {
public static void main(String[] args) {
// Primitive
types int num1 =
5;
int num2 = 5;
System.out.println("num1 == num2: " + (num1 == num2)); //
true
 // Reference types
(String) String str1 =
"Hello"; String str2 =
"Hello";
String str3 = new String("Hello");

System.out.println("str1 == str2: " + (str1 == str2)); //

true (string pool)
System.out.println("str1 == str3: " + (str1 == str3));
// false (different objects)
System.out.println("str1.equals(str3): " +
str1.equals(str3));
// true (content comparison)

// Reference types
(Integer) Integer intObj1
= 10; Integer intObj2 =
10;
Integer intObj3 = new Integer(10);

System.out.println("intObj1 == intObj2: " + (intObj1 ==

intObj2)); // true (Integer pool)
System.out.println("intObj1 == intObj3: " + (intObj1 ==
intObj3)); // false (different objects)
System.out.println("intObj1.equals(intObj3): " +
intObj1.equals(intObj3)); // true (content comparison)
}
}
Q8. Write a java program that uses nested if else statements to determine a
students letter grade based on their numerical score. Then explain how the
nested if else statements operate in your program.
import java.util.Scanner;

public class GradeCalculator {

public static void main(String[] args) {
Scanner scanner = new
Scanner(System.in);
System.out.print("Enter the student's numerical score:
"); int score = scanner.nextInt();
char grade;
if (score >= 90)
{ grade =
'A';
} else if (score >= 80) {
grade = 'B';
} else if (score >= 70) {
grade = 'C';
} else if (score >= 60) {
grade = 'D';
} else {
grade = 'F';
}
System.out.println("The student's grade is: " + grade);
scanner.close();
}
}
Explanation:
1. Input: The program takes a numerical score as input.
2. Nested if-else:
○ The program uses a series of nested if-else statements to check the score
against different ranges.
○ The first if condition checks if the score is 90 or above. If it is, the grade is 'A'.
○ If the first condition is false, the program moves to the next else if
condition, which checks if the score is 80 or above.
○ This continues until a condition is met or the final else statement is reached.
3. Grade Assignment: Based on the score, the appropriate grade is assigned.
4. Output: The program displays the student's grade.

Q9. Difference between prefix and postfix increment and decrement operators.
Provide code examples to illustrate the behavior of each.
Prefix Operators (++var, --var):
● The operator is applied before the variable's value is used in the expression.
● The variable's value is modified first, and then the modified value is used.
Postfix Operators (var++, var--):
● The operator is applied after the variable's value is used in the expression.
● The variable's value is used first, and then the variable is modified.
Examples:
public class IncrementDecrement {
public static void main(String[]
args) { int x = 5;
int y = ++x; // Prefix increment
 System.out.println("x: " + x); // x is now 6
System.out.println("y: " + y); // y is 6

int a = 5;
int b = a++; // Postfix increment

System.out.println("a: " + a); // a is now 6

System.out.println("b: " + b); // b is 5

int c = 5;
int d = --c; // Prefix decrement

System.out.println("c: " + c); // c is now 4

System.out.println("d: " + d); // d is 4

int e = 5;
int f = e--; // Postfix decrement

System.out.println("e: " + e); // e is now 4

System.out.println("f: " + f); // f is 5
}
}
Q10. Write a java program that utilizes a for loop to print out the numbers 1
through 10, and then uses a seperate for loop to print out the same numbers in
reverse order. public class ForLoopReverse {
public static void main(String[] args) {
// Print 1 through 10
System.out.println("Numbers 1 through
10:"); for (int i = 1; i <= 10; i++) {
System.out.print(i + " ");
}
System.out.println(); // Newline

// Print 10 through 1
System.out.println("Numbers 10 through
1:"); for (int i = 10; i >= 1; i--) {
System.out.print(i + " ");
}
System.out.println(); // Newline
}
}
Q11. Define the terms 'class' and 'object' in the context of object-oriented
programming. Explain the relationship between them.
Class:
● In object-oriented programming (OOP), a class serves as a blueprint or
template for creating objects.
● It encapsulates data (attributes or fields) and methods (behaviors or
functions) that operate on that data.
● A class defines the structure and behavior that its objects will possess. It's a
logical construct, not a physical entity.
● Think of a class as a cookie cutter; it defines the shape, but the cookie itself is the
object.
Object:
● An object is an instance of a class. It's a real-world entity that has its own state
(values of its attributes) and behavior (actions it can perform).
● Objects are created from classes and occupy memory.
● Each object has its own unique identity and can have different values for its
attributes.
● Continuing the cookie analogy, the cookies produced by the cookie cutter are the
objects.
Relationship:
● The relationship between a class and an object is that of a blueprint and an
instance.
● A class defines the structure and behavior, while an object is a concrete
realization of that definition.
● Multiple objects can be created from a single class, each with its own state.
● Objects interact with each other by invoking methods, which are defined in their
classes.
Example:
class Car {
String make;
String model;
int year;

void startEngine() {
System.out.println("Engine started.");
}
}

public class ClassObjectExample {

public static void main(String[] args) {
Car car1 = new Car(); // car1 is an object of class Car
car1.make = "Toyota";
car1.model = "Camry";
car1.year = 2022;
car1.startEngine();

Car car2 = new Car(); // car2 is another object of

class Car car2.make = "Honda";
car2.model = "Civic";
car2.year = 2023;
car2.startEngine();
}
}
Q12. Explain the concept of method overriding with a suitable
example. Method Overriding:
● Method overriding occurs when a subclass provides a specific
implementation for a method that is already defined in its superclass.
● The overriding method in the subclass must have the same name, return
type, and parameter list as the method in the superclass.
● Method overriding is a form of runtime polymorphism, where the appropriate
method is called based on the object's actual type.
● The @Override annotation is used to show that a method is intented to
override a superclass method.
Example:
class Animal {
void makeSound() {
System.out.println("Animal makes a sound.");
}
}
class Dog extends Animal {
@Override
void makeSound() {
System.out.println("Dog barks.");
}
}
public class MethodOverridingExample {
public static void main(String[]
args) {
Animal animal = new
Animal(); Dog dog = new
Dog();
animal.makeSound(); // Output: Animal makes a
sound. dog.makeSound(); // Output: Dog
barks.
Animal animal2 = new Dog();
animal2.makeSound(); //Output: Dog
barks.
 }
}

Q13. Differences between method overloading and method overriding. Provide

code examples to illustrate each concept and explain when each would be
used.
Method Overloading:
● Method overloading occurs within the same class when multiple methods have
the same name but different parameter lists (number, type, or order of
parameters).
● The compiler determines which overloaded method to call based on the
arguments passed during the method invocation.
● Overloading is a compile time polymorphism.
Method Overriding:

● Method overriding occurs when a subclass provides a specific

implementation for a method that is already defined in its superclass.
● The overriding method must have the same name, return type, and parameter
list as the method in the superclass.
● Overriding is a runtime polymorphism.
Examples:
Method Overloading:
class Calculator {
int add(int a, int b) {
return a + b;
}
double add(double a, double b)
{ return a + b;
}
int add(int a, int b, int c) {
return a + b + c;
}
}

public class MethodOverloadingExample {

public static void main(String[]
args) {
Calculator calculator = new Calculator();
System.out.println(calculator.add(5, 10)); //
Output:
15 system.out.println(calculator.add(5.5, 10.5)); //
Output: System.out.println(calculator.add(5, 10, 15)); //
16.0 Output:

30
}
}
Method Overriding:
(See example in Q12)
When to Use:
● Method Overloading: Use when you want to provide multiple ways to perform
the same operation with different types or numbers of arguments.
● Method Overriding: Use when you want a subclass to provide a
specialized implementation of a method that is already defined in its
superclass.

Q14. Explain the importance of encapsulation in object-oriented design.

Encapsulation:
● Encapsulation is one of the four fundamental principles of OOP. It involves
bundling data (attributes) and methods (behaviors) that operate on that data into
a single unit (class).
● It also involves hiding the internal implementation details of a class and
providing a controlled interface for accessing and modifying the data.
Importance:
1. Data Hiding: Encapsulation protects data from unauthorized access or
modification. By making attributes private and providing public getter and setter
methods, you can control how the data is accessed and modified.
2. Modularity: Encapsulation promotes modularity by dividing a program into self-
contained units (classes). This makes the code easier to understand, maintain,
and modify.
3. Code Reusability: Encapsulated classes can be reused in different parts of a
program or in other programs, reducing code duplication.
4. Flexibility and Maintainability: Encapsulation allows you to change the
internal implementation of a class without affecting other parts of the
program, as long as the public interface remains the same.
5. Reduced Complexity: Encapsulation simplifies the overall design of a program
by hiding unnecessary details and providing a clear interface for interacting with
objects.
Q15. Create a class Employee with attributes empId, name, and salary.
Implement encapsulation by making the attributes private and providing getter
and setter methods. public class Employee {
private int empId;
private String name;
private double
salary;

// Getter methods
public int getEmpId()
{
return empId;
}

public String getName() {

return name;
}

public double getSalary()

{ return salary;
}

// Setter methods
public void setEmpId(int empId) {
this.empId = empId;
}

public void setName(String name) {

this.name = name;
}

public void setSalary(double salary) {

this.salary = salary;
 }

public static void main(String[]

args){ Employee emp = new
Employee(); emp.setEmpId(12345);
emp.setName("John Doe");
emp.setSalary(50000.00);

System.out.println("Employee ID: "+ emp.getEmpId());

System.out.println("Employee Name: "+ emp.getName());
System.out.println("Employee Salary: "+
emp.getSalary());
}
}

This code demonstrates proper encapsulation by making the attributes empId, name,
and salary private and providing public getter and setter methods for controlled access.
Q16. Design a class hierarchy that demonstrates inheritance and polymorphism.
Create an abstract class 'Shape' with an abstract method 'calculateArea().' Then
create concrete classes 'Circle' and 'Square' that inherit from 'Shape' and
implement 'calculateArea().' Concept:
● Inheritance: Allows a class (subclass/derived class) to inherit properties and
methods from another class (superclass/base class).
● Polymorphism: Allows objects of different classes to be treated as objects of a
common type. In this case, through the abstract Shape class.
● Abstract Class: A class that cannot be instantiated directly and may contain
abstract methods (methods without implementation).
● Abstract Method: A method declared in an abstract class that must be
implemented by concrete subclasses.

Code (Python):
import math
from abc import ABC,
abstractmethod class Shape(ABC):
@abstractmethod
def calculateArea(self):
pass

class Circle(Shape):
def init (self,
radius): self.radius
= radius

def calculateArea(self):
return math.pi * self.radius * self.radius

class Square(Shape):
def init (self,
side): self.side =
side
 def calculateArea(self):
return self.side * self.side

# Example Usage
circle = Circle(5)
square = Square(4)
shapes = [circle,
square] for shape in
shapes:
print(f"Area: {shape.calculateArea()}")

Explanation:
1. Shape Class:
○ It's an abstract base class (ABC) using the abc module.
○ It defines an abstract method calculateArea(), which forces subclasses to
provide their own implementation.
2. Circle Class:
○ Inherits from Shape.
○ Has a radius attribute.
○ Implements calculateArea() to calculate the area of a circle.
3. Square Class:
○ Inherits from Shape.
○ Has a side attribute.
○ Implements calculateArea() to calculate the area of a square.
4. Polymorphic Behavior:
○ The shapes list can hold objects of both Circle and Square.
○ When shape.calculateArea() is called, the appropriate calculateArea()
method is executed based on the object's actual type. This demonstrates
runtime polymorphism.
Q17. Write a class that utilizes private variables, and then uses public getter and
setter methods to access and modify those private variables.
Concept:
● Encapsulation: The practice of bundling data (attributes) and methods that
operate on the data into a single unit (class).
● Private Variables: Variables that are only accessible within the class itself.
● Getter Methods: Public methods that retrieve the values of private variables.
● Setter Methods: Public methods that modify the values of private variables.
Code (Python):
class Person:
def init (self, name, age):
self. name = name # Private
variable self. age = age #
Private variable

def get_name(self):
return self.
nam
e
def set_name(self,
name): self. name =
name
def get_age(self):
return self.
ag
e
def set_age(self,
age): if age >= 0:
self. age =
age else:
print("Age cannot be negative.")
# Example Usage
person = Person("Alice", 30)
print(f"Name:
{person.get_name()}")
print(f"Age:
{person.get_age()}")

person.set_age(31)
print(f"Updated Age:
{person.get_age()}") person.set_age(-
5)
Explanation:
1. Private Variables:
○ name and age are private variables (indicated by the double underscore
).
○ They cannot be accessed directly from outside the Person class.
2. Getter Methods:
○ get_name() and get_age() provide read-only access to the private variables.
3. Setter Methods:
○ set_name() and set_age() allow controlled modification of the private
variables.
○ The set_age method has a validation check, to ensure that the age is not
negative.
4. Encapsulation:
○ The internal state of the Person object is protected.
○ External code can only interact with the object through the defined public
methods.
Q18. Analyze the different forms of polymorphism, and explain the situations
that each form is best suited for.
Forms of Polymorphism:
1. Compile-Time Polymorphism (Static Polymorphism):
○ Achieved through method overloading and operator overloading.
○ The appropriate method or operator is determined at compile time.
2. Runtime Polymorphism (Dynamic Polymorphism):
○ Achieved through method overriding.
○ The appropriate method is determined at runtime based on the object's
actual type.
Situations and Explanations:
1. Compile-Time Polymorphism:
○ Method Overloading:
■ Defining multiple methods with the same name but different
parameters within the same class.
■ Best suited for situations where you want to provide different ways to
perform the same operation based on the input types or number of
arguments.
■ Example: A calculateArea() method that can accept either a radius
(for a circle) or a side (for a square).
○ Operator Overloading:
■ Defining how operators (e.g., +, -, *) should behave with objects of a
class.
■ Best suited for making custom objects behave naturally with
standard operators.
■ Example: Overloading the + operator for a Vector class to perform
vector addition.
2. Runtime Polymorphism:
○ Method Overriding:
■ A subclass provides a specific implementation for a method that is
already defined in its superclass.
 ■ Best suited for situations where you want to provide specialized
behavior for subclasses while maintaining a common interface.
■ Example: The calculateArea() example from Q16. The Circle and
Square classes override the calculateArea() method from the Shape
class to provide their own area calculation logic.
○ Interface Implementation:
■ An interface defines a contract that classes must adhere to. Any
class that implements the interface must provide implementations
for all of the interface's methods.
■ Best suited for situations where you want to create a loosely coupled
system where different classes can be used interchangeably as long
as they implement the same interface.
■ Example: A payment processing system that has an interface for
payment gateways. Different payment gateways (e.g., Stripe,
PayPal) can be implemented as classes that implement the
interface.
Q19. Create a base class named "Vehicle", and then create two child classes
named "Car" and "Motorcycle". Override a method named "displayType()" in each
of the child classes. Then create an array of vehicle objects, that contains car and
motorcycle objects. Then loop through the array, and call the displayType method
on each object. Explain what happens, and why.
Code (Python):
class Vehicle:
def displayType(self):
print("This is a generic vehicle.")

class Car(Vehicle):
def displayType(self):
print("This is a car.")
class
Motorcycle(Vehicle):
def
displayType(self):
print("This is a motorcycle.")
# Create an array of vehicle objects
vehicles = [Car(), Motorcycle(),
Car()]
# Loop through the array and call
displayType() for vehicle in vehicles:
vehicle.displayType()
Explanation:
1. Base Class Vehicle:
○ Defines a displayType() method that provides a generic message.
2. Child Classes Car and Motorcycle:
○ Inherit from Vehicle.
○ Override the displayType() method to provide specific messages for
cars and motorcycles.
3. Array of Vehicle Objects:

○ The vehicles list contains objects of type Car and Motorcycle.

4. Loop and Polymorphic Behavior:
○ The for loop iterates through the vehicles list.
○ For each vehicle object, vehicle.displayType() is called.
○ What Happens:
■ The output will be:
This is a car.
This is a
motorcycle. This is
a car.

○ **
Q20. Illustrate the significance of the super keyword in Java? Explain with an
example. Significance of super:
The super keyword in Java is used to access members (methods and variables) of the
superclass (parent class) from within a subclass. It's crucial for:
1. Calling Superclass Constructors: When a subclass constructor is called,
super() is used to explicitly call the superclass constructor, ensuring that the
superclass's initialization logic is executed.
2. Accessing Superclass Methods: super.methodName() allows a subclass
to call a method defined in the superclass, even if the subclass overrides
that method.
3. Accessing Superclass Variables: super.variableName allows a subclass to
access a variable defined in the superclass, even if the subclass has a variable
with the same name.
Example:
class Animal {
String name;

Animal(String name) {
this.name = name;
System.out.println("Animal constructor called with name: "
+
name);
}

void makeSound() {
System.out.println("Generic animal sound.");
}
}

class Dog extends Animal {

String breed;
 Dog(String name, String breed) {
super(name); // Calling superclass
constructor this.breed = breed;
System.out.println("Dog constructor called with breed: " +
breed);
}

@Override
void makeSound() {
super.makeSound(); // Calling superclass method
System.out.println("Woof!");
}

void displayInfo() {
System.out.println("Name: " + super.name); // Accessing
superclass variable
System.out.println("Breed: " + breed);
}
}

public class SuperExample {

public static void main(String[] args) {
Dog myDog = new Dog("Buddy", "Golden Retriever");
myDog.makeSound();
myDog.displayInfo();
}
}

Explanation:
 ● In the Dog constructor, super(name) calls the Animal constructor, initializing
the name variable.
● In Dog.makeSound(), super.makeSound() calls the Animal.makeSound() method
before adding the Dog-specific "Woof!" sound.
● In Dog.displayInfo(), super.name accesses the name variable from the
Animal class. Q21. Explain the concept of abstraction in object-oriented
programming, and then evaluate how it is used to simplify complex systems.
Abstraction in OOP:
Abstraction is the process of hiding complex implementation details and showing only
the essential features of an object or system. It focuses on "what" an object does rather
than "how" it does it.
How Abstraction Simplifies Complex Systems:
1. Reduced Complexity: By hiding unnecessary details, abstraction reduces the
cognitive load on developers. They can work with simplified models of objects
and systems.
2. Improved Modularity: Abstraction allows complex systems to be broken down
into smaller, manageable modules. Each module exposes a clear interface,
hiding its internal complexity.
3. Enhanced Maintainability: Changes in the implementation of an abstracted
component don't necessarily affect other parts of the system, as long as the
interface remains the same.
4. Increased Reusability: Abstract classes and interfaces define common
behaviors, allowing different classes to implement them and be used
interchangeably.
5. Simplified Design: Abstraction helps in creating a high-level design by focusing
on the essential features and relationships between objects.
Example:
Consider a car. You don't need to know how the engine, transmission, or brakes work
internally. You just need to know how to use the steering wheel, accelerator, and
brakes to drive the car. The car's interface (steering wheel, pedals) abstracts away the
complex internal workings.

Q22. Explain the purpose of the try-catch-finally block in Java exception handling.
Describe the role of each keyword.
Purpose of try-catch-finally:
The try-catch-finally block is used for handling exceptions in Java. It allows you to
gracefully handle errors and prevent your program from crashing.
Roles of Keywords:
1. try:

○ Encloses the code that might throw an exception.

○ If an exception occurs within the try block, the execution jumps to the
corresponding catch block.
2. catch:
○ Handles specific types of exceptions.
○ Each catch block specifies the type of exception it can handle.
○ If an exception of the specified type is thrown within the try block, the code
within the corresponding catch block is executed.
3. finally:
○ Contains code that is always executed, regardless of whether an
exception is thrown or caught.
○ Used for cleanup operations, such as closing resources (files,
network connections).
Q23. Write a Java program that creates a custom exception, and then throws that
exception when a specific condition is met.
class CustomException extends Exception {
public CustomException(String message)
{
super(message);
}
}

public class CustomExceptionExample {

public static void checkAge(int age) throws
CustomException { if (age < 18) {
throw new CustomException("Age must be 18 or older.");
}
System.out.println("Age is valid.");
}

public static void main(String[] args)

{ try {
checkAge(15);
} catch (CustomException e) {
System.out.println("Caught exception: " +
e.getMessage());
}
}
}
Q24. Explain the difference between checked and unchecked exceptions in Java.
Checked Exceptions:
● These exceptions are checked at compile time.
● If a method throws a checked exception, it must either be caught using a try-
catch block or declared in the method's throws clause.
● Examples: IOException, SQLException.
● These exceptions typically represent recoverable errors.
Unchecked Exceptions:
● These exceptions are not checked at compile time.
● They are subclasses of RuntimeException or Error.
● They do not need to be caught or declared.
● Examples: NullPointerException, ArrayIndexOutOfBoundsException,
ArithmeticException.
● These exceptions typically represent programming errors or unexpected
conditions.\
Q25. Write a Java program that creates two threads. Then use the join method to
ensure that the main thread waits for both threads to complete before
continuing. Then explain what the join method does, and how it works.
class MyThread extends Thread {
public MyThread(String name)
{
super(name);
}

@Override
public void run() {
System.out.println(getName() + "
started."); try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName() + " finished.");
}
}

public class JoinExample {

public static void main(String[] args) {
MyThread thread1 = new MyThread("Thread
1"); MyThread thread2 = new
MyThread("Thread 2");

thread1.start();
thread2.start();

try {
thread1.join();
thread2.join();
}
 catch (InterruptedException e) {
e.printStackTrace();
}

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

}
}

Explanation of join():
● The join() method causes the current thread to wait until the thread on which it
is called terminates.
● In the example, thread1.join() makes the main thread wait until thread1 finishes
execution, and thread2.join() makes the main thread wait until thread2 finishes.
● This ensures that the "Main thread finished." message is printed only after both
threads have completed.
Q26. Write a Java program that creates two threads. One thread should print
even numbers from 1 to 20, and the other thread should print odd numbers from
1 to 20. Ensure that the numbers are printed in ascending order (1, 2, 3, ...20).
public class EvenOddThreads {
private static int number =
1;
private static final int MAX = 20;
private static final Object lock = new Object();

static class EvenThread extends Thread

{ @Override
public void run() {
synchronized (lock) {
while (number <= MAX)
{ if (number % 2 ==
0) {

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

number);
number++;
lock.notify();
} else {
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
 static class OddThread extends Thread
{ @Override
public void run() {
synchronized (lock) {
while (number <= MAX)
{ if (number % 2 !=
0) {

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

number);
number++;
lock.notify();
} else {
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}

public static void main(String[] args) {

EvenThread evenThread = new
EvenThread(); OddThread oddThread =
new OddThread();

evenThread.setName("EvenThread");
oddThread.setName("OddThread");

oddThread.start();
 evenThread.start();
}
}

Explanation:
1. Shared Resource: number is the shared resource, and lock is the object
used for synchronization.
2. synchronized Block: Each thread uses a synchronized block to ensure that
only one thread can access the shared resource at a time.
3. wait() and notify():
○ If a thread finds that it's not its turn (e.g., even thread finds an odd number),
it calls lock.wait() to release the lock and wait.
○ When a thread finishes its turn, it calls lock.notify() to wake up the other
waiting thread.
4. Order: The logic ensures that the threads alternate, printing numbers in
ascending order. Q27. Create a multithreaded Java program that utilizes a shared
resource, and then use synchronized blocks to prevent race conditions. Then
explain what a race condition is, and how your solution prevents it.
class Counter {
private int count = 0;

public void increment() {

synchronized (this) {
count++;
}
}
public int getCount() {
synchronized (this) {
return count;
}
}
}

class IncrementThread extends Thread {

 private Counter counter;

public IncrementThread(Counter
counter) { this.counter = counter;
}

@Override
public void run() {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
}
}

public class RaceConditionExample {

public static void main(String[] args) throws
InterruptedException
{
Counter counter = new Counter();
IncrementThread thread1 = new IncrementThread(counter);
IncrementThread thread2 = new IncrementThread(counter);

thread1.start();
thread2.start();

thread1.join();
thread2.join();

System.out.println("Final count: " + counter.getCount());

}
}

Race Condition:
● A race condition occurs when multiple threads access and modify a shared
 resource concurrently, and the final outcome depends on the unpredictable
order in which the threads execute.
● In the absence of synchronization, the count++ operation might not be atomic.
One thread might read the value of count, another thread might also read the
same value, and then both threads might increment and write back the same
incremented value, leading to a loss of updates.
How Synchronization Prevents Race Conditions:
● The synchronized (this) block ensures that only one thread can execute the
code within the block at a time.
● When a thread enters the synchronized block, it acquires a lock on the Counter
object. Other threads attempting to enter the same block will be blocked until
the first thread releases the lock.
● This ensures that the count++ operation is performed atomically,
preventing race conditions.
Q28. Explain the purpose of the finally block, and then evaluate the situations
where it is

important to use a finally block.

Purpose of finally Block:
● The finally block is used to ensure that a block of code is always executed,
regardless of whether an exception is thrown or caught.
● It is typically used for cleanup operations, such as releasing resources
(closing files, network connections, etc.).
Situations Where finally Is Important:
1. Resource Cleanup:
○ When working with resources like files, network connections, or
database connections, it's crucial to release them even if an
exception occurs.
○ The finally block guarantees that these resources are closed, preventing
resource leaks.
2. Guaranteed Execution:
○ In situations where certain code must be executed regardless of
exceptions, the finally block ensures that it happens.
○ For example, logging a message or performing a cleanup action that should
always occur.
3. Preventing Resource Leaks:
○ If a method opens a file, and an exception is thrown before the file is closed,
the file will remain open if there is no finally block.
○ Using finally prevents this.
Q29. Write a Java program that takes two integer inputs and performs division.
Implement exception handling to catch and handle ArithmeticException if the
divisor is zero.
import java.util.Scanner;

public class DivisionExample {

public static void main(String[] args) {
Scanner scanner = new
Scanner(System.in);

try {
System.out.print("Enter numerator:
"); int numerator =
scanner.nextInt();

System.out.print("Enter denominator:
"); int denominator =
scanner.nextInt();

int result = numerator / denominator;

System.out.println("Result: " + result);
} catch (ArithmeticException e) {
System.out.println("Error: Division by zero is not
allowed.");
} catch (java.util.InputMismatchException e) {
System.out.println("Error: Invalid input. Please enter
integers.");
} finally {
scanner.close();
}
 }
}

Explanation:
1. try Block:
○ Contains the code that might throw an ArithmeticException (division by zero).
○ Also includes a catch for InputMismatchException in case the user does
not enter an integer.
2. catch Block:
○ Handles the ArithmeticException if it occurs.
○ Prints an error message indicating that division by zero is not allowed.
3. finally Block:
○ Closes the Scanner object to release resources, regardless of
whether an exception occurred.