UNIT I: Basics of Java Programming

SHORT ANSWER QUESTIONS

1. What is Object-Oriented Programming (OOP)?

Object-Oriented Programming (OOP) is a programming paradigm based on the concept of "objects,"
which can contain data (fields or attributes) and code (methods). OOP promotes principles like
encapsulation, inheritance, polymorphism, and abstraction to model real-world problems
efficiently. Examples include Java, Python, and C++.
2. Explain the purpose of command-line arguments in Java.
Command-line arguments are used to pass information to a Java program during its execution. These
arguments are received as an array of String in the main method (public static void main(String[] args)).
They allow customization of the program's behavior without modifying the code.
Example:

public class CommandLineExample {

public static void main(String[] args) {
for (String arg : args) {
[Link](arg);
}
}
}

3. List and explain any two escape sequences in Java.

o \n: Inserts a new line. Example: "Hello\nWorld" outputs:

▪ Hello
▪ World
o \t: Inserts a horizontal tab. Example: "Hello\tWorld" outputs:
Hello World

4. What is a literal in Java? Give examples.

A literal is a fixed value directly assigned to a variable in Java.
Examples:
o Integer literal: int x = 10;
o Floating-point literal: double pi = 3.14;
o Character literal: char ch = 'A';
o String literal: String name = "Java";
5. How does the print() method work in Java?
The print() method in Java is used to output text to the console. Unlike println(), it does not move the
cursor to a new line after printing.
Example:

[Link]("Hello ");
[Link]("World");

Output: Hello World

1. DESCRIBE THE BASIC STRUCTURE OF A JAVA PROGRAM, INCLUDING ELEMENTS LIKE CLASS,
MAIN METHOD, AND STATEMENTS.

The basic structure of a Java program consists of the following elements:

1. Package Declaration (Optional):

If the program belongs to a specific package, it is declared at the top.
Example:

package mypackage;

2. Import Statements (Optional):

Used to include Java libraries or user-defined classes.
Example:

import [Link];

3. Class Declaration:
Every Java program must have at least one class, defined using the class keyword. The class
name should match the filename.
Example:

public class HelloWorld {

4. Main Method:
This is the entry point of the program. The main method has a fixed syntax:

public static void main(String[] args) {

// Code to be executed
}

5. Statements:
The body of the main method contains the program logic, which can include:
o Variable declarations.
o Method calls.
o Control structures (e.g., loops, if-else).

Example of a Simple Java Program:

// Package Declaration (optional)

package mypackage;

// Import Statement (optional)

import [Link];

// Class Declaration
public class HelloWorld {
// Main Method
public static void main(String[] args) {
// Program Logic
 [Link]("Hello, World!"); // Prints a message to the console
}
}

Explanation of Key Components:

• Class: Serves as a blueprint for objects. The program resides within a class.
• Main Method: Acts as the starting point for program execution.
• Statements: Provide the actual functionality, such as printing, calculations, or interacting
with the user.

2. EXPLAIN THE SCOPE OF VARIABLES IN JAVA WITH EXAMPLES OF LOCAL, INSTANCE, AND STATIC
VARIABLES.

In Java, the scope of a variable refers to the portion of the program where the variable is accessible.
There are three main types of variables based on their scope:

1. LOCAL VARIABLES:

• Declared within a method, constructor, or block.

• Accessible only within that specific block.
• They must be initialized before use.

Example:

public class LocalExample {

public void display() {
int localVar = 10; // Local variable
[Link]("Local Variable: " + localVar);
}
}

Key Points:

• Scope: Inside the method/block only.

• Lifetime: Exists as long as the method executes.

2. INSTANCE VARIABLES:

• Declared inside a class but outside methods or blocks.

• Belong to the object (instance) of the class.
• Each object has its copy of instance variables.

Example:

public class InstanceExample {

int instanceVar = 20; // Instance variable
 public void display() {
[Link]("Instance Variable: " + instanceVar);
}
}

Key Points:

• Scope: Accessible by all methods of the class through the object.

• Lifetime: Exists as long as the object exists.

3. STATIC VARIABLES:

• Declared using the static keyword inside the class.

• Shared among all objects of the class.
• Only one copy exists in memory, irrespective of the number of objects.

Example:

public class StaticExample {

static int staticVar = 30; // Static variable

public static void display() {

[Link]("Static Variable: " + staticVar);
}
}

Key Points:

• Scope: Accessible by all methods of the class, including static methods.

• Lifetime: Exists throughout the program's execution.

Comparison Table:

Type Scope Lifetime Keyword

Local Method/block only During method execution None

Instance Entire class, via object As long as the object exists None

Static Entire class, shared Throughout the program static

3. DESCRIBE DIFFERENT DATA TYPES AVAILABLE IN JAVA. EXPLAIN THE ROLE OF TYPE CASTING
WITH EXAMPLES.

DATA TYPES IN JAVA

In Java, data types specify the type of values that variables can hold. They are divided into two main
categories: Primitive and Non-Primitive.

1. PRIMITIVE DATA TYPES

Primitive data types are the most basic data types in Java. There are 8 primitive data types:

Type Description Size Example

byte Stores integers 1 byte -128 to 127
short Stores integers 2 bytes -32,768 to 32,767
Int Stores integers 4 bytes 12345
Long Stores large integers 8 bytes 123456789L
Float Stores fractional numbers 4 bytes 3.14f
Double Stores precise decimals 8 bytes 3.14159
Char Stores single characters 2 bytes 'A'
boolean Stores true/false values 1 bit true, false
EXAMPLES OF PRIMITIVE DATA TYPES:
public class PrimitiveExample {
public static void main(String[] args) {
int age = 25; // Integer
float height = 5.8f; // Float
char initial = 'A'; // Character
boolean isJavaFun = true; // Boolean
[Link]("Age: " + age);
[Link]("Height: " + height);
[Link]("Initial: " + initial);
[Link]("Is Java Fun? " + isJavaFun);
}
}

2. NON-PRIMITIVE DATA TYPES

Non-primitive data types are more complex and include objects, arrays, and strings.
Examples:

• String: Stores a sequence of characters.

Example: String name = "Java";
• Array: Stores a collection of similar data types.
Example: int[] numbers = {1, 2, 3};
ROLE OF TYPE CASTING IN JAVA

Type casting refers to converting a variable from one data type to another. It is useful for handling
data in cases where compatibility is required between types. There are two types of type casting:

1. IMPLICIT TYPE CASTING (WIDENING CONVERSION):

• Automatically converts smaller data types to larger ones.

• No loss of data occurs.
• Example:

int num = 10;

double d = num; // Implicit casting
[Link](d); // Output: 10.0
2. EXPLICIT TYPE CASTING (NARROWING CONVERSION):

• Converts larger data types to smaller ones.

• Data loss might occur.
• Requires explicit syntax using parentheses.
• Example:

double value = 99.99;

int num = (int) value; // Explicit casting
[Link](num); // Output: 99

EXAMPLES OF TYPE CASTING

EXAMPLE PROGRAM:
public class TypeCastingExample {
public static void main(String[] args) {
// Implicit Casting
int num = 100;
double d = num;
[Link]("Implicit Casting: " + d); // Output: 100.0

// Explicit Casting
double value = 99.99;
int intValue = (int) value;
[Link]("Explicit Casting: " + intValue); // Output: 99
}
}
OUTPUT:
Implicit Casting: 100.0
Explicit Casting: 99
WHY TYPE CASTING IS IMPORTANT?

1. Memory Optimization: Narrowing conversions can save memory when large data types are
not required.
2. Compatibility: Helps in combining operations between different data types.
3. Efficient Data Handling: Widens compatibility in calculations and conversions, especially
when using libraries.

4. DISCUSS VARIOUS OPERATORS IN JAVA, SUCH AS ARITHMETIC, LOGICAL, AND RELATIONAL

OPERATORS, WITH EXAMPLES

In Java, operators are symbols or keywords used to perform operations on variables and values.
They are categorized into several types, including arithmetic, logical, and relational operators.

1. ARITHMETIC OPERATORS

Used to perform basic mathematical operations like addition, subtraction, multiplication, etc.

Operator Description Example Output

+ Addition 10 + 5 15
- Subtraction 10 - 5 5
* Multiplication 10 * 5 50
/ Division 10 / 5 2
% Modulus (Remainder) 10 % 3 1

Example Program:

public class ArithmeticExample {

public static void main(String[] args) {
int a = 10, b = 5;
[Link]("Addition: " + (a + b));
[Link]("Subtraction: " + (a - b));
[Link]("Multiplication: " + (a * b));
[Link]("Division: " + (a / b));
[Link]("Modulus: " + (a % b));
}
}

2. LOGICAL OPERATORS

Used to combine multiple boolean expressions or conditions.

Operator Description Example Output

&& Logical AND (a > b) && (a < 20) true
` ` Logical OR
! Logical NOT !(a == b) true
Example Program:

public class LogicalExample {

public static void main(String[] args) {
int a = 10, b = 5;
[Link]("Logical AND: " + ((a > b) && (a < 20)));
[Link]("Logical OR: " + ((a < b) || (a > 5)));
[Link]("Logical NOT: " + !(a == b));
}
}

3. RELATIONAL OPERATORS

Used to compare two values and return a boolean result.

Operator Description Example Output

== Equal to a == b false
!= Not equal to a != b true
> Greater than a>b true
< Less than a<b false
>= Greater than or equal a >= b true
<= Less than or equal a <= b false

Example Program:

public class RelationalExample {

public static void main(String[] args) {
int a = 10, b = 5;
[Link]("Equal to: " + (a == b));
[Link]("Not equal to: " + (a != b));
[Link]("Greater than: " + (a > b));
[Link]("Less than: " + (a < b));
}
}

5. EXPLAIN THE CONCEPT OF CONTROL STATEMENTS IN JAVA AND DIFFERENTIATE BETWEEN

FOR, WHILE, AND DO-WHILE LOOPS WITH EXAMPLES

Control statements in Java determine the flow of program execution. They include decision-making
statements, looping statements, and branching statements. Among these, looping statements are
used to execute a block of code repeatedly based on a condition.

TYPES OF LOOPS IN JAVA:

1. for Loop
o Used when the number of iterations is known in advance.
o Syntax:
 for (initialization; condition; increment/decrement) {
// Code to execute
}

o Example:

public class ForLoopExample {

public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
[Link]("Iteration: " + i);
}
}
}

o Output:

Iteration: 1
Iteration: 2
Iteration: 3
Iteration: 4
Iteration: 5

2. while Loop
o Used when the number of iterations is not fixed and depends on a condition.
o Syntax:

while (condition) {
// Code to execute
}

o Example:

public class WhileLoopExample {

public static void main(String[] args) {
int i = 1;
while (i <= 5) {
[Link]("Iteration: " + i);
i++;
}
}
}

o Output:Iteration: 1

Iteration: 2
Iteration: 3
Iteration: 4
Iteration: 5
 3. do-while Loop
o Similar to while, but ensures the loop body is executed at least once, even if the
condition is false.
o Syntax:

do {
// Code to execute
} while (condition);

o Example:

public class DoWhileLoopExample {

public static void main(String[] args) {
int i = 1;
do {
[Link]("Iteration: " + i);
i++;
} while (i <= 5);
}
}

o Output:

Iteration: 1
Iteration: 2
Iteration: 3
Iteration: 4
Iteration: 5

COMPARISON OF LOOPS
Loop Execution Use Case
for Executes when the number of iterations is known. Iterating over arrays or fixed
sequences.
while Executes when a condition is true. Repeating until a condition
changes.
do- Executes the code at least once before checking the When the code must run at least
while condition. once.
 UNIT II: Classes, Objects, and Methods
Short Answer Questions:
1. WHAT IS A CLASS IN JAVA?

A class in Java is a blueprint for creating objects. It defines properties (fields) and behaviors
(methods) that the objects created from it can have.

Example:

class Car {
String model;
int year;
}

2. EXPLAIN THE PURPOSE OF THE THIS KEYWORD IN JAVA.

The this keyword in Java refers to the current instance of a class. It is used to:

1. Differentiate between instance variables and parameters.

2. Call another constructor within the same class.

Example:

class Car {
String model;
Car(String model) {
[Link] = model; // Refers to instance variable
}
}

3. WHAT IS AN OVERLOADED CONSTRUCTOR?

An overloaded constructor is when a class has multiple constructors with the same name but
different parameters. It allows creating objects in various ways.

Example:

class Car {
Car() {} // Default constructor
Car(String model) {} // Parameterized constructor
}

4. HOW DOES PASSING PARAMETERS BY VALUE WORK IN JAVA?

In Java, all arguments are passed by value. For primitive data types, the value is copied. For objects,
the reference (address) is copied, not the object itself.
Example:

void changeValue(int a) {
a = 10; // Changes only the local copy
}

5. WHAT IS THE DIFFERENCE BETWEEN STATIC AND FINAL KEYWORDS IN JAVA?

Feature Static Final

Purpose Belongs to the class, not an instance. Prevents modification or inheritance.

Usage Applied to methods, variables, or blocks. Applied to variables, methods, or classes.

Example:

static int count; // Shared among all instances

final int max = 100; // Value cannot be changed

Long Answer Questions:

1. DISCUSS THE CONCEPT OF ACCESS MODIFIERS IN JAVA AND EXPLAIN THEIR ROLE IN DEFINING
VISIBILITY FOR CLASS MEMBERS

Access modifiers in Java control the visibility of class members (variables, methods, constructors)
and classes themselves. They play a crucial role in implementing encapsulation, a core concept in
Object-Oriented Programming. Java provides four types of access modifiers:

TYPES OF ACCESS MODIFIERS

1. Public (public):
o Members are accessible from anywhere in the program (across all packages).
o Example:

public class Example {

public int value = 10;

public void show() {

[Link]("Public Access Modifier");
}
}

2. Private (private):
o Members are accessible only within the class where they are defined.
o Example:

class Example {
private int value = 10;
 private void show() {
[Link]("Private Access Modifier");
}
}

3. Protected (protected):
o Members are accessible within the same package and in subclasses (even in different
packages).
o Example:

class Example {
protected int value = 20;

protected void show() {

[Link]("Protected Access Modifier");
}
}

4. Default (No Modifier):

o Members are accessible only within the same package (package-private).
o Example:

class Example {
int value = 30;

void show() {
[Link]("Default Access Modifier");
}
}

ROLE OF ACCESS MODIFIERS

1. Encapsulation: Restricts access to sensitive data and provides controlled access.

Example: Using private fields and public getters/setters for secure data access.
2. Security: Protects data from unauthorized access or modification.
3. Inheritance: Allows sharing of certain members with subclasses using protected.
4. Code Readability and Maintenance: Clear visibility rules make code easier to maintain.

2. EXPLAIN CONSTRUCTORS IN JAVA, FOCUSING ON PARAMETERIZED AND DEFAULT

CONSTRUCTORS, WITH EXAMPLES
WHAT IS A CONSTRUCTOR?

A constructor is a special method used to initialize objects. It is called automatically when an object
is created and must share the same name as the class.
TYPES OF CONSTRUCTORS

1. Default Constructor:
o A constructor that takes no arguments and initializes fields to default values.
o Example:

class DefaultConstructor {
int value;

DefaultConstructor() {
value = 10;
}

void show() {
[Link]("Value: " + value);
}
}

public class Main {

public static void main(String[] args) {
DefaultConstructor obj = new DefaultConstructor();
[Link](); // Output: Value: 10
}
}

2. Parameterized Constructor:
o A constructor that takes arguments to initialize fields with specific values.
o Example:

class ParameterizedConstructor {
int value;

ParameterizedConstructor(int value) {
[Link] = value;
}

void show() {
[Link]("Value: " + value);
}
}

public class Main {

public static void main(String[] args) {
ParameterizedConstructor obj = new ParameterizedConstructor(25);
[Link](); // Output: Value: 25
}
}
IMPORTANCE OF CONSTRUCTORS

1. Eliminates the need for manual initialization of fields.

2. Provides flexibility in creating objects with different initial values (using parameterized
constructors).
3. Enables better code readability and reusability.

3. DESCRIBE METHOD OVERLOADING AND METHOD OVERRIDING WITH EXAMPLES, INCLUDING

THEIR USE CASES IN OOP
METHOD OVERLOADING

• Definition: Method overloading allows defining multiple methods with the same name but
different parameter lists.
• Key Points:
o Compile-time polymorphism.
o Improves code readability by grouping similar operations under a single method
name.

Example of Method Overloading:

class Calculator {
int add(int a, int b) {
return a + b;
}

double add(double a, double b) {

return a + b;
}
}

public class Main {

public static void main(String[] args) {
Calculator calc = new Calculator();
[Link]("Sum (int): " + [Link](10, 20));
[Link]("Sum (double): " + [Link](10.5, 20.5));
}
}

METHOD OVERRIDING

• Definition: Method overriding allows a subclass to provide its own implementation of a

method already defined in its superclass.
• Key Points:
o Runtime polymorphism.
o Ensures dynamic behavior.

Example of Method Overriding:

class Parent {
void display() {
[Link]("Parent Class Method");
}
}

class Child extends Parent {

@Override
void display() {
[Link]("Child Class Method");
}
}

public class Main {

public static void main(String[] args) {
Parent obj = new Child();
[Link](); // Output: Child Class Method
}
}

USE CASES IN OOP

1. Method Overloading: Simplifies method grouping for related functionalities (e.g., println()).
2. Method Overriding: Achieves runtime polymorphism for dynamic behavior in frameworks

4. Discuss the Use of Recursion in Java, Providing an Example Program to Illustrate Recursive
Functions

USE OF RECURSION IN JAVA

Recursion in Java refers to the process where a method calls itself to solve a problem. It is a
powerful technique that breaks down a problem into smaller, more manageable sub-problems, often
making the solution more elegant and easier to implement. Recursive methods are commonly used in
problems involving repetitive tasks, such as factorial computation, Fibonacci series, tree traversal,
and more.

HOW RECURSION WORKS:

1. Base Case: The base case is the condition under which the recursion stops. Without a base
case, the recursive method would keep calling itself indefinitely, resulting in a stack
overflow.
2. Recursive Case: The recursive case is the part where the method calls itself with a modified
parameter that brings it closer to the base case.

ADVANTAGES OF RECURSION:

• Simplifies complex problems by breaking them into smaller sub-problems.

• Leads to cleaner and more concise code, especially for problems with a natural recursive
structure.
 • Useful in problems like searching and sorting, tree and graph traversal, and combinatorics.

DISADVANTAGES OF RECURSION:

• Can lead to high memory consumption due to the function call stack.
• May be slower than iterative solutions due to the overhead of multiple function calls.

EXAMPLE OF A RECURSIVE FUNCTION: FACTORIAL CALCULATION

One classic example of recursion is the factorial function, where the factorial of a number n is
defined as:

• n! = n * (n-1) * (n-2) * ... * 1

• 0! = 1 (base case)

The recursive approach to calculating factorial is as follows:

• If n = 0, return 1 (base case).

• Otherwise, return n * factorial(n-1) (recursive case).

RECURSIVE PROGRAM TO CALCULATE FACTORIAL

public class Factorial {

// Recursive method to calculate factorial

public static int factorial(int n) {
if (n == 0) {
return 1; // Base case: factorial of 0 is 1
} else {
return n * factorial(n - 1); // Recursive case
}
}

public static void main(String[] args) {

int number = 5; // Number for which factorial is to be calculated
int result = factorial(number);
[Link]("Factorial of " + number + " is " + result); // Output: 120
}
}
EXPLANATION OF THE PROGRAM:

1. Base Case: The factorial() method checks if n == 0, in which case it returns 1. This is the
termination point of the recursion.
2. Recursive Case: If n != 0, the method calls itself with the argument n - 1 and multiplies the
result by n. This process continues until the base case is reached.
3. The main() method calls the factorial() function with the value 5, and the result is printed.

STEP-BY-STEP EXECUTION FOR FACTORIAL(5):

• factorial(5) calls factorial(4) → 5 * factorial(4)

 • factorial(4) calls factorial(3) → 4 * factorial(3)
• factorial(3) calls factorial(2) → 3 * factorial(2)
• factorial(2) calls factorial(1) → 2 * factorial(1)
• factorial(1) calls factorial(0) → 1 * factorial(0)
• factorial(0) returns 1 (base case)
• The result propagates back:
o factorial(1) = 1 * 1 = 1
o factorial(2) = 2 * 1 = 2
o factorial(3) = 3 * 2 = 6
o factorial(4) = 4 * 6 = 24
o factorial(5) = 5 * 24 = 120

Thus, factorial(5) returns 120.

KEY POINTS TO NOTE:

• Base Case: Always make sure that the recursion has a stopping point (base case), otherwise
the program will run indefinitely.
• Recursive Call: Each recursive call should bring the problem closer to the base case. In the
above example, each call decreases the value of n until n = 0.

EXAMPLE: FIBONACCI SEQUENCE

Another common example of recursion is the Fibonacci sequence, where each number is the sum of
the two preceding ones:

• F(0) = 0
• F(1) = 1
• F(n) = F(n-1) + F(n-2) for n > 1

Here’s the recursive implementation:

public class Fibonacci {

// Recursive method to calculate Fibonacci number

public static int fibonacci(int n) {
if (n <= 1) {
return n; // Base case: Fibonacci of 0 or 1 is the number itself
} else {
return fibonacci(n - 1) + fibonacci(n - 2); // Recursive case
}
}

public static void main(String[] args) {

int number = 6; // Fibonacci number for index 6
int result = fibonacci(number);
[Link]("Fibonacci of " + number + " is " + result); // Output: 8
}
}
EXPLANATION OF FIBONACCI PROGRAM:

1. Base Case: The method checks if n is 0 or 1 and returns the value of n. This is because F(0) =
0 and F(1) = 1 are the starting points of the sequence.
2. Recursive Case: If n > 1, the method calls itself twice — once for fibonacci(n-1) and once
for fibonacci(n-2) — and returns their sum.

For fibonacci(6), the calculation goes as:

• fibonacci(6) = fibonacci(5) + fibonacci(4)

• fibonacci(5) = fibonacci(4) + fibonacci(3)
• And so on, until the base cases are reached.

[Link] HOW ARRAYS ARE STORED IN MEMORY AND DISCUSS THE USE OF TWO-DIMENSIONAL
ARRAYS WITH EXAMPLES
INTRODUCTION TO ARRAYS

An array is a data structure in Java that stores elements of the same data type in contiguous memory
locations. Arrays are indexed, allowing easy access to elements using their position.

MEMORY STORAGE OF ARRAYS

1. Single-Dimensional Arrays:
o Stored in contiguous memory locations.
o Each element is indexed starting from 0 to n-1 (where n is the size of the array).
o Example:

int[] arr = {10, 20, 30};

// Memory representation:
// Index: 0 1 2
// Value: 10 20 30

2. Two-Dimensional Arrays:
o A two-dimensional array is an array of arrays.
o Rows are stored sequentially in memory.
o Example:

int[][] matrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
// Memory representation:
// Row 1: 1 2 3
// Row 2: 4 5 6
// Row 3: 7 8 9

3. Heap Memory:
 o Arrays in Java are stored in heap memory, while references are stored in stack
memory.
o For two-dimensional arrays, each row is stored as a separate array in heap memory.

EXAMPLE OF TWO-DIMENSIONAL ARRAYS

Program to Create and Display a Two-Dimensional Array

public class TwoDArrayExample {

public static void main(String[] args) {
int[][] matrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};

// Displaying the 2D array

[Link]("Two-Dimensional Array:");
for (int i = 0; i < [Link]; i++) {
for (int j = 0; j < matrix[i].length; j++) {
[Link](matrix[i][j] + " ");
}
[Link]();
}
}
}

Output:

Two-Dimensional Array:
123
456
789

ADVANTAGES OF TWO-DIMENSIONAL ARRAYS

1. Tabular Data Representation:

o Simplifies the representation of data like matrices, grids, or tables.
2. Efficient Storage:
o Elements are stored sequentially, reducing overhead.
3. Index-Based Access:
o Accessing elements using indices is fast.
o Example: matrix[1][2] retrieves the value 6 in the above example.

APPLICATIONS OF TWO-DIMENSIONAL ARRAYS

1. Matrix Operations:
 o Two-dimensional arrays are widely used in solving matrix-based problems such as
addition, subtraction, and multiplication of matrices.
2. Game Development:
o Grids in games like Tic-Tac-Toe, Chess, or Minesweeper are represented using 2D
arrays.
3. Image Processing:
o Pixels of an image can be stored in a two-dimensional array.
4. Dynamic Programming:
o Algorithms like the Longest Common Subsequence (LCS) or Matrix Chain
Multiplication use 2D arrays for storing intermediate results.

MEMORY REPRESENTATION IN TWO-DIMENSIONAL ARRAYS

In Java, two-dimensional arrays are not stored in a single block of memory like in C/C++. Instead,
they are implemented as arrays of arrays (jagged arrays). This allows rows to have different lengths.

Example of a Jagged Array:

public class JaggedArray {

public static void main(String[] args) {
int[][] jagged = {
{1, 2},
{3, 4, 5},
{6}
};

for (int i = 0; i < [Link]; i++) {

for (int j = 0; j < jagged[i].length; j++) {
[Link](jagged[i][j] + " ");
}
[Link]();
}
}
}

Output:

Copy code
12
345
6
 UNIT-3 ARRAYS & INHERITANCE

Short Answer Questions

1. What is inheritance in Java?

Inheritance in Java is a mechanism where one class acquires the properties (fields) and behaviors
(methods) of another class. It enables code reusability and establishes a relationship between the
parent class (superclass) and child class (subclass), where the child class inherits fields and
methods of the parent class.

2. What does the super keyword do in Java?

The super keyword in Java is used to refer to the immediate parent class object. It is used to access
parent class methods and constructors, particularly when the child class has overridden methods
or has a constructor that needs to call a specific constructor in the parent class.

3. What is a final class, and why would you use one?

final class in Java is a class that cannot be subclassed. It is declared with the final keyword and is often
used for security and design purposes to prevent alteration of its behavior by inheritance. For
example, the String class in Java is final to ensure the integrity and immutability of string data.

4. Define an interface and explain its purpose in Java.

An interface in Java is a reference type, similar to a class, that can contain only abstract methods and
constants. Interfaces are used to define a contract of methods that implementing classes must
follow, promoting abstraction and multiple inheritance, as a class can implement multiple
interfaces.

5. What is the difference between an abstract class and an interface?

An abstract class can have both abstract and concrete methods, but a class can only inherit from one
abstract class. An interface, on the other hand, can only contain abstract methods (until Java 8,
which introduced default and static methods) and supports multiple inheritance. Abstract classes
are used when classes share common functionality, while interfaces define a set of methods that
unrelated classes can implement.
Long Answer Questions

1. Explain the process of inheritance in Java and describe how it promotes code reusability.
Provide examples.

1. INTRODUCTION
• Inheritance is the backbone of object-oriented programming (OOP).
• It is the mechanism by which a class can acquire properties and methods of another class.
• Using inheritance, an already tested and debugged class program can be reused for some
other application.
• Super class This is the existing class from which another class, that is, the subclass is
generally derived.
• In Java, several derived classes can have the same super class.
• Subclass A class that is derived from another class is called subclass.
• In Java, a subclass can have only one super class.

BENEFITS OF INHERITANCE
• It allows the reuse of already developed and debugged class program without any
modification.
• It allows a number of subclasses to fulfil the needs of several subgroups.
• A large program may be divided into suitable classes and subclasses that may be
developed by separate teams of programmers.
DISADVANTAGES OF INHERITANCE
1. The tight coupling between super and subclasses increases and it becomes very difficult to
use them independently.
2. Program processing time increases as it takes more time for the control to jump
through various levels of overloaded classes.
3. When some new features are added to super and derived classes as a part of
maintenance, the changes affect both the classes.
4. When some methods are deleted in super class that is inherited by a subclass, the
methods of subclass will no longer override the super class method.

2. PROCESS OF INHERITANCE
• Inheritance means deriving some characteristics from something that is generic.
• In the context of Java, it implies deriving a new class from an existing old class, that is, the
super class.
• A super class describes general characteristics of a class of objects.
• A subset of these objects may have characteristics different from others.
• There are two ways of dealing with this problem.
• Either, make a separate class for the subset to include all the characteristics or, to have
another class that inherits the existing class, extend this class to include the special
characteristics.

3. TYPES OF INHERITANCES
The following types of inheritances are supported by Java.
1. Single inheritance
2. Multilevel inheritance
3. Hierarchical inheritance
4. Multiple inheritance using interfaces

1. Single inheritance: It is the simple type of inheritance. In this, a class extends another
one class only.
Example:[Link]
class DemoA
{ void displayA()
{
[Link]("Super Class Method");
}}
class DemoB extends DemoA
{
void displayB()
{
[Link]("Sub Class Method");
}
}
class SingleInheritance
{
public static void main(String args[])
{
DemoA objA = new DemoA(); [Link]();

DemoB objB = new DemoB(); [Link]();

}}
OUTPUT:
C:\>javac [Link] C:\>java SingleInheritance
Super Class Method Sub Class
Method
[Link] inheritance: In this type, a derived class inherits a parent

or super class; The derived class also acts as the parent class to other class.

EXAMPLE: [Link]
class DemoA
{
void displayA()
{
[Link]("Class-A Method");
}
}

class DemoB extends DemoA

{
void displayB()
{
[Link]("Class-B Method");
}
}

class DemoC extends DemoB

{
void displayC()
{
[Link]("Class-C Method");
}
}

class Multilevel
{
public static void main(String args[])
{
//calling class-A method DemoA objA = new
DemoA(); [Link]();
//calling class-B method DemoB objB = new
DemoB(); [Link]();

//calling class-C method DemoC objC = new

DemoC(); [Link]();
} }
Output:
C:\>javac [Link]
C:\>java Multilevel Class-A
Method Class-B Method
Class-C Method
[Link] inheritance: In this type, one class is inherited by many sub classes.
EXAMPLE: [Link]
class DemoA

{
void displayA()
{
[Link]("Class-A Method");
}
}
class DemoB extends DemoA
{
void displayB()
{
[Link]("Class-B Method");
}
}

class DemoC extends DemoA

{
void displayC()
{
[Link]("Class-C Method");
}}
class Heirarchical
{
public static void main(String args[])
{
//calling class-A method DemoA objA = new
DemoA(); [Link]();

//calling class-B method DemoB objB = new

DemoB(); [Link]();

//calling class-C method DemoC objC = new

DemoC(); [Link]();
}
}

Output:

C:\ >javac [Link]

C:\ >java Hierarchical Class-A

Method
Class-B Method Class-C
Method
iii. Multiple inheritance: In this, a class is extending more than one class.
• Java does not support multiple inheritance.
• This implies that a class cannot extend more than one class.
• Suppose there is a method in class A. This method is overridden in class B and class C in
their own way.
• Since class C extends both the classes A and B.
• So, if class C uses the same method, then there will be ambiguity as which method is
called.

Example: [Link]

interface X
{
int x=10;
}

interface Y
{
int y=20;
}

class DemoA
{
void displayA()
{ [Link]("Class-A Method");
} }
class DemoB extends DemoA implements X,Y
{
 void displayB()
{
[Link]("Class-B Method : x+y = " +
(x+y));
}
}
class Multiple
{
public static void main(String args[])
{
//calling class-A method DemoA objA = new
DemoA(); [Link]();

//calling class-B method DemoB objB = new

DemoB(); [Link]();

}
}

Output:
C:\ >javac [Link]

C:\ >java Multilevel Class-A

Method
Class-B Method Class-C
Method
2. Discuss the concept of polymorphism in Java, focusing on compile-time and runtime
polymorphism, with examples.

Polymorphism is a fundamental concept in Java, derived from the Greek word "poly" (many) and
"morph" (forms). In programming, polymorphism allows objects to be accessed in different
forms depending on their class types or implemented interfaces. This ability enables the same
action or method to perform differently based on the context, enhancing flexibility,
extensibility, and maintainability in Java code. Java supports two primary types of
polymorphism: compile-time polymorphism (method overloading) and runtime
polymorphism (method overriding).
COMPILE-TIME POLYMORPHISM (METHOD OVERLOADING)

Compile-time polymorphism occurs when the decision of which method to execute is made at
compile time. It is achieved through method overloading, where multiple methods in the same
class share the same name but differ in their parameter list (either in type, number, or both).

This type of polymorphism is called "compile-time" because the compiler can determine which
method version to call based on the method signature. Method overloading is commonly used
to perform a similar operation in different ways or with varying parameters, improving code
readability and reusability.

Example of Compile-Time Polymorphism (Method Overloading):

class Calculator {
// Method to add two integers
int add(int a, int b) {
return a + b;
}

// Overloaded method to add three integers

int add(int a, int b, int c) {
return a + b + c;
}

// Overloaded method to add two doubles

double add(double a, double b) {
return a + b;
}
}

public class Main {

public static void main(String[] args) {
Calculator calc = new Calculator();

// Calling the overloaded methods

[Link]("Sum of 2 and 3: " + [Link](2, 3)); // Calls add(int, int)
[Link]("Sum of 2, 3, and 4: " + [Link](2, 3, 4)); // Calls add(int, int, int)
[Link]("Sum of 5.5 and 4.5: " + [Link](5.5, 4.5)); // Calls add(double, double)
}
}

Explanation:
In this example, the Calculator class has three overloaded versions of the add method. The Java
compiler determines which method to call based on the arguments passed:

• [Link](2, 3) calls add(int, int).

• [Link](2, 3, 4) calls add(int, int, int).
• [Link](5.5, 4.5) calls add(double, double).

This is resolved at compile time, so it’s known as compile-time polymorphism.

RUNTIME POLYMORPHISM (METHOD OVERRIDING)

Runtime polymorphism occurs when a subclass provides a specific implementation of a method

already defined in its superclass. This is known as method overriding, where a child class
overrides the method of its parent class to provide specialized behavior.

Runtime polymorphism is determined during program execution (runtime), making it possible for the
same method to behave differently depending on the object calling it. This is especially
important for achieving dynamic behavior in Java and allows developers to write flexible and
extensible code.

Example of Runtime Polymorphism (Method Overriding):

class Animal {
// Base method in superclass
void sound() {
[Link]("Animal makes a sound");
}
}

class Dog extends Animal {

// Overridden method in subclass
@Override
void sound() {
[Link]("Dog barks");
}
}

class Cat extends Animal {

// Overridden method in subclass
@Override
void sound() {
[Link]("Cat meows");
}
}

public class Main {

public static void main(String[] args) {
// Creating superclass reference holding subclass objects
Animal myDog = new Dog();
Animal myCat = new Cat();
// Calling the overridden methods
[Link](); // Calls Dog's version of sound()
[Link](); // Calls Cat's version of sound()
}
}

Explanation:
In this example, the Animal class has a sound method, which is overridden by both Dog and
Cat subclasses. The Main class creates an Animal reference that holds instances of Dog and Cat
objects. At runtime, Java dynamically decides which sound method to call based on the actual
object type. As a result:

• [Link]() invokes the overridden sound method in Dog, printing "Dog barks."
• [Link]() invokes the overridden sound method in Cat, printing "Cat meows."

This dynamic selection of methods at runtime demonstrates runtime polymorphism.

3. Describe how to create and implement interfaces in Java, including examples of multiple
interfaces in a single class.

In Java, an interface is a reference type, similar to a class, that defines a collection of abstract
methods (methods without a body) and constants. Interfaces are used to specify a contract of
behaviors that any implementing class must follow, making them a key tool for achieving
abstraction and multiple inheritance in Java.

1. DECLARATION OF INTERFACE
• Declaration of an interface starts with the access modifier followed by keyword
interface.
• It is in then followed by its name or identifier that is followed by a block of
statements;
• These statements contain declarations of variables and abstract methods.
• The variables defined in interfaces are implicitly public, static, and final.
• They are initialized at the time of declaration. The methods declared in an
interface are public by default.
MEMBERS OF INTERFACE
• The members declared in the body of the interface.
• The members inherited from any super interface that it extends.
• The methods declared in the interface are implicitly public abstract member
methods.
• The field variables defined in interfaces are implicitly public, static, and final.
• However, the specification of these modifiers does not create a compile-type error.
• The field variables declared in an interface must be initialized; otherwise,
compile-type error occurs.
• Since Java SE8, static and default methods with full definition can also be
members of interface.
2. IMPLEMENTATION OF INTERFACE
Declaration of class that implements an interface

If a class extends another class as well as implements interfaces, it is declared as

3. MULTIPLE INTERFACES
• Multiple interfaces can also be implemented in Java.
• For this, the class implements all the methods declared in all the interfaces.
• When the class is declared, names of all interfaces are listed after the keyword
implements and separated by comma.
• As for example, if class A implements interfaces C and D, it is defined as
Example: Multiple.

Example:

interface Printable {
void print();
}

interface Showable {
void show();
}

class Demo implements Printable, Showable {

public void print() {

[Link]("Printing...");
}

public void show() {

[Link]("Showing...");
}
}

Here, the Demo class implements both Printable and Showable interfaces, demonstrating the concept
of multiple inheritance through interfaces.

4. Explain dynamic method dispatch in Java and discuss its importance in achieving runtime
polymorphism with examples.

DYNAMIC METHOD DISPATCH IN JAVA

Dynamic Method Dispatch is a technique in Java that allows the method call to be resolved at
runtime, based on the actual object type that a reference variable points to. It is a key feature for
achieving runtime polymorphism, which enables different objects to respond to the same
method call in their own unique way.

In Java, dynamic method dispatch is primarily achieved through method overriding, where a subclass
provides a specific implementation for a method defined in its superclass. The actual method that
is called is determined at runtime based on the type of the object, not the type of the reference
variable.
HOW DYNAMIC METHOD DISPATCH WORKS

Dynamic method dispatch works by:

1. Using a superclass reference to point to subclass objects.

2. The method call is resolved at runtime, depending on the actual class of the object the reference
variable is pointing to.
3. The Java Virtual Machine (JVM) looks up the overridden method in the subclass and invokes the
appropriate method.

This behavior is crucial for achieving runtime polymorphism, where the same method can perform
different tasks depending on the object that calls it.

IMPORTANCE OF DYNAMIC METHOD DISPATCH IN ACHIEVING RUNTIME POLYMORPHISM

Dynamic method dispatch is central to runtime polymorphism because it allows:

1. Flexibility in Code: A reference variable of a superclass type can refer to objects of different
subclass types. This allows the same method to behave differently depending on the actual object
being referenced at runtime.
2. Code Reusability: It promotes the reuse of code, as the method signatures can remain the same
across different classes, while the method implementation can vary based on the class.
3. Dynamic Behavior: The ability to resolve method calls at runtime provides dynamic behavior in
applications, making the system adaptable to changes (e.g., adding new subclasses).
4. Extensibility: New subclasses can be added without changing the code that uses the superclass
reference, thus achieving high flexibility and extensibility.

EXAMPLE OF DYNAMIC METHOD DISPATCH IN JAVA

Consider a simple example where we have a superclass Animal, and two subclasses Dog and Cat. Each
subclass overrides the sound() method.

// Superclass Animal
class Animal {
void sound() {
[Link]("Animal makes a sound");
}
}

// Subclass Dog
class Dog extends Animal {
@Override
void sound() {
[Link]("Dog barks");
}
}
class Cat extends Animal {
@Override
void sound() {
[Link]("Cat meows");
}
}

public class Main {

public static void main(String[] args) {
// Superclass reference pointing to Dog object
Animal myAnimal = new Dog();
[Link](); // Output: Dog barks

// Superclass reference pointing to Cat object

myAnimal = new Cat();
[Link](); // Output: Cat meows
}

[Link] the purpose and benifits of abstract classes in [Link] example where abstract
classes are useful?

PURPOSE AND BENEFITS OF ABSTRACT CLASSES IN JAVA

In Java, abstract classes are classes that cannot be instantiated directly. They are used as a blueprint
for other classes. An abstract class can contain both abstract methods (methods without a body)
and concrete methods (methods with a body). The purpose and benefits of abstract classes in
Java can be summarized as follows:

PURPOSE OF ABSTRACT CLASSES:

1. Code Reusability:
o Abstract classes allow you to define common functionality in one place. The subclasses can then
inherit this functionality, reducing code duplication.
2. Defining Common Interface:
o An abstract class can provide a common interface for all subclasses. The abstract methods ensure
that each subclass implements the necessary behavior, but the common functionality can be
shared.
3. Enforcing a Contract:
o By declaring abstract methods, the abstract class enforces a contract. Any concrete subclass must
provide implementations for these methods, ensuring a consistent structure.
4. Partial Implementation:
o Abstract classes allow partial implementation of functionality. You can define some methods
with concrete implementations, while leaving others abstract for subclasses to implement.

BENEFITS OF ABSTRACT CLASSES:

1. Code Organization:
o Abstract classes allow for better organization of code by grouping related behaviors and
properties that will be shared among subclasses.
2. Flexibility and Extensibility:
o Abstract classes provide a level of flexibility and extensibility. They allow new classes to be
added to the system without changing the existing code base, adhering to the Open/Closed
Principle.
3. Preventing Instantiation of Base Class:
o Abstract classes cannot be instantiated directly, which prevents creating objects of classes that
are not fully defined. This ensures that only fully implemented subclasses can be instantiated.
4. Facilitates Polymorphism:
o Abstract classes enable polymorphism. You can create references to abstract classes and assign
objects of any subclass type to them, making your code more flexible and allowing for different
behaviors.

EXAMPLE WHERE ABSTRACT CLASSES ARE USEFUL:

Let's consider a scenario where you're modeling different types of vehicles. You can create an abstract
class Vehicle to define common properties and methods, and then create specific subclasses like
Car and Bike.

// Abstract class
abstract class Vehicle {

String brand;
int year;

// Constructor
public Vehicle(String brand, int year) {
[Link] = brand;
[Link] = year;
}

// Abstract method (no implementation)

public abstract void startEngine();

// Concrete method (implementation)

public void displayDetails() {
[Link]("Brand: " + brand + ", Year: " + year);
}
}

// Concrete class Car

class Car extends Vehicle {
public Car(String brand, int year) {
super(brand, year);
}

// Implementing the abstract method

@Override
public void startEngine() {
[Link]("Starting car engine...");
}
}

// Concrete class Bike

class Bike extends Vehicle {
public Bike(String brand, int year) {
super(brand, year);
}

// Implementing the abstract method

@Override
public void startEngine() {
[Link]("Starting bike engine...");
}
}public class Main {
public static void main(String[] args) {
Vehicle car = new Car("Toyota", 2020);

[Link]();
[Link]();

Vehicle bike = new Bike("Harley", 2018);

[Link]();
[Link]();
}
}

Output:

Brand: Toyota, Year: 2020

Starting car engine...
Brand: Harley, Year: 2018
Starting bike engine...

UNIT IV: PACKAGES AND EXCEPTION HANDLING

SHORT ANSWER QUESTIONS:

[Link] is a package in Java?

A package in Java is a namespace used to group related classes, interfaces, and sub-packages. It helps
organize classes and interfaces, avoiding name conflicts, and makes code easier to manage. There
are two types of packages:

1. Built-in packages (e.g., [Link], [Link]).

2. User-defined packages (e.g., [Link]).

[Link] do you import a package in a Java program?

You can import a package using the import keyword. To import all classes from a package:

import [Link].*;

To import a specific class:

import [Link];

3. What is the difference between checked and unchecked exceptions in Java?

Checked exceptions are exceptions that are checked at compile-time. They must be either caught
using a try-catch block or declared in the method signature using throws. Example: IOException,
SQLException.

Unchecked exceptions are exceptions that occur at runtime. They are subclasses of RuntimeException
and do not need to be declared or handled. Example: NullPointerException,
ArithmeticException.

[Link] the purpose of the finally block in exception handling.

The finally block is used to execute important code (such as cleanup operations) that needs to run
regardless of whether an exception occurs or not. The finally block is executed after the try and
catch blocks, even if an exception is thrown. It's commonly used for closing resources like files
or database connections.

try {
// code that might throw an exception
} catch (Exception e) {
// exception handling code
} finally {
// cleanup code (always executes)
}

[Link] is the throw keyword used for in Java?

The throw keyword is used to explicitly throw an exception in Java. It can be used to throw both built-
in exceptions and custom exceptions.

throw new ArithmeticException("Division by zero");

Long Answer Question:
[Link] a Package in Java and Discuss Its Importance in Larger Applications?
CREATING A PACKAGE IN JAVA:

A package in Java is a mechanism for organizing Java classes into namespaces, allowing for better
management of large codebases and avoiding naming conflicts. A package groups related classes,
interfaces, and sub-packages together. Java provides both built-in packages (such as [Link] and
[Link]) and allows developers to create their own user-defined packages.

STEPS TO CREATE A PACKAGE IN JAVA:

Define the Package:

o At the top of your Java class file, you declare the package using the package keyword. The name
of the package should match the directory structure where the file will be stored.

Copy codepackage [Link]; // Declaring the package

Create the Package Directory Structure:

o After declaring the package, save your Java file in a corresponding directory structure. For
example, if your package is [Link], you should save the file in a folder structure like
com/myapp/utilities/.

Compile the Java File:

o After creating the class file, you can compile it from the command line. If the file is
[Link], you would use:

javac com/myapp/utilities/[Link]

Import and Use the Package:

o To use the package in another class, you import it with the import statement:

import [Link];

Example of a Package in Java:

[Link] (class in a package)

package [Link];

public class MyUtility {

public static void displayMessage() {
[Link]("This is a utility class!");
}
}
[Link] (using the package)

import [Link];

public class Main {

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

Output:

This is a utility class!

IMPORTANCE OF USING PACKAGES IN LARGER APPLICATIONS:

Code Organization:

1. In large applications, code organization becomes critical. Packages help group related classes
and interfaces, making it easier to manage and navigate the code. Instead of having thousands of
classes in one directory, you can group them logically, such as separating classes related to
database operations ([Link]) from those related to user interface ([Link]).

Avoiding Naming Conflicts:

2. Without packages, class names can conflict. For example, two developers might create a
Customer class in different parts of the application. By using packages, these classes can have the
same name but exist in different namespaces (e.g., [Link] and
[Link]), avoiding conflicts and ensuring that each class can be uniquely
referenced.

Access Control and Encapsulation:

3. Packages can be used to control access to classes and methods. Java provides different levels of
access control (public, protected, default, private) within packages. For example:
▪ A class or method declared as public is accessible from anywhere.
▪ A class or method with default access (no modifier) is accessible only within the same package.
4. This helps enforce encapsulation, keeping the internal workings of a class hidden from other
parts of the application and only exposing necessary functionality.

Improved Code Reusability:

5. Packages make it easier to reuse code. When a class is packaged in a specific module (e.g.,
[Link]), you can reuse it across different parts of the application or even in different
projects by importing the package. This is particularly useful for libraries and utility classes.

Maintainability:

6. As applications grow, maintaining them becomes more challenging. Using packages helps
organize code in a way that makes it easier to track and update different modules of the system.
 For example, if you need to update a database-related class, you can find it easily within the
[Link] package.

Enhanced Collaboration:

7. In larger development teams, multiple developers might work on different parts of the application
simultaneously. Packages provide a logical separation of concerns, allowing teams to work on
their respective modules without interfering with each other. For example, one team can work on
the payment processing module ([Link]), while another works on user
authentication ([Link]).

Better Documentation:

8. By grouping related classes into packages, you can also organize the documentation. Packages
provide a natural way to document parts of the system, making it easier for new developers to
understand the project structure.

Namespace Management:

9. Packages help in namespace management by grouping related classes and avoiding naming
collisions. For example, a Logger class in one part of the application might conflict with a
Logger class in another part. By placing them in different packages, each can have the same
name without causing ambiguity.

Deployment and Distribution:

When deploying applications, especially large ones, packages help organize the distribution of classes.
For example, you might bundle different parts of the application (e.g., core functionality, user
interface, utility classes) into separate JAR files or modules, making the deployment process
easier and more manageable.

Java API and Third-Party Libraries:

Java’s standard library (API) itself is built using packages. The [Link] package, for example, contains
utility classes like ArrayList and HashMap. Similarly, third-party libraries also use packages to
organize their classes, which allows you to import only the classes you need, optimizing your
application.

[Link] the hierarchy of exception classes in Java, giving examples of common checked and
unchecked exceptions.

1. HIERARCHY OF STANDARD EXCEPTION CLASSES

• In Java, exceptions are instances of classes derived from the class Throwable
which in turn is derived from class Object.
• Whenever an exception is thrown, it implies that an object is thrown.
• Only objects belonging to class that is derived from class Throwable can be
thrown as exceptions.
• The next level of derived classes comprises two classes: the class Error and class
 Exception.
• Error class involves errors that are mainly caused by the environment in which an
application is running.
• All errors in Java happen during runtime.

• Examples
OutOfMemoryError occurs when the JVM runs out of memory and
StackOverflowError occurs when the stack overflows.
• Exception class represents exceptions that are mainly caused by the application itself.
• IT IS NOT POSSIBLE TO RECOVER FROM AN ERROR USING TRY–CATCH BLOCKS.
• The only option available is to terminate the execution of the program and recover
from exceptions using either the try–catch block or throwing an exception.
• The exception class has several subclasses that deal with the exceptions that are caught
and dealt with by the user’s program.
• The Error class includes such errors over which a programmer has less control.
• A programmer cannot do anything about these errors except to get the error message and
check the program code.
• A programmer can have control over the exceptions (errors) defined by several
subclasses of class Exception.

The subclasses of Exception class are broadly subdivided into two categories.
Unchecked exceptions These are subclasses of class RuntimeException, derived from
Exception class. For these exceptions, the compiler does not check whether the method
that throws these exceptions has provided any exception handler code or not.

Checked exceptions These are direct subclasses of the Exception class and are not subclasses of
the class RuntimeException. These are called so because the compiler ensures (checks)
that the methods that throw checked exceptions deal with them.

This can be done in two ways:

1. The method provides the exception handler in the form of appropriate try–catch blocks.
2. The method may simply declare the list of exceptions that the method may throw with
throws clause in the header of the method.
• In this case, the method need not provide any exception handler.
• It is a reminder for those who use the method to provide the appropriate exception
handler.
• If a method does not follow either of the aforementioned ways, the compilation will
result in an error.

METHODS DEFINED IN CLASS THROWABLE

Example: [Link]

class TryCatchDemo
{
public static void main(String args[])
{
int i=6,j=0,k; try {
[Link]("Entered try block"); k=i/j;
[Link]("Exiting try block");
}
catch (ArithmeticException e)
{
[Link]("e = " + e);
}
[Link]("End of the Program ");
}
}
Output:
C:\ >javac [Link]

C:\ >java TryCatchDemo Entered try

block

e = [Link]: / by zero End of the Program

3. Discuss the use of try, catch, and finally blocks in Java for handling exceptions, with examples.
[Link], CATCH AND FINALLY BLOCKS
TRY {} BLOCK
• The program code that is most likely to create exceptions is kept in the try block,
which is followed by the catch block to handle the exception.
• In normal execution, the statements are executed and if there are no exceptions, the
program flow goes to the code line after the catch blocks.
• However, if there is an exception, an exception object is thrown from the try block.
• Its data members keep the information about the type of exception thrown.
• The program flow comes out of the try block and searches for an appropriate catch
block with the same type as its argument.
CATCH {} BLOCK
• A catch block is meant to catch the exception if the type of its argument matches with the
type of exception thrown.
• If the type of exception does not match the type of the first catch block, the program flow
checks the other catch blocks one by one.
• If the type of a catch block matches, its statements are executed.
• If none matches, the program flow records the type of exception, executes the finally
block, and terminates the program.
EXAMPLE: [Link]

class TryCatchDemo2
{
public static void main(String args[])
{
int i=6,j=0,k; try {
[Link]("Entered try block"); k=i/j;
[Link]("Exiting try block");
}
catch (ArithmeticException e)
{
[Link]("e = " + e);
}

j=2; // Value of j Changed [Link]("When J =2, i/j = " + i/j);

[Link]("End of the Program ");
}
}
Output:

C:\ >javac [Link]

C:\ >java TryCatchDemo2 Entered try

block
e = [Link]: / by zero When J =2, i/j = 3
End of the Program
FINALLY {} BLOCK
• This is the block of statements that is always executed even when there is an
exceptional condition, which may or may not have been caught or dealt with.
• Thus, finally block can be used as a tool for the clean up operations and for recovering the
memory resources.
• For this, the resources should be closed in the finally block.
• This will also guard against situations when the closing operations are bypassed by
statements such as continue, break, or return.
FINALIZE() IN EXCEPTION HANDLING
• finalize() method releases system resources before the garbage collector runs for a
specific object.
• JVM allows finalize() to be invoked only once per object
• THE SYNTAX FOR USING FINALIZE() METHOD IS GIVEN AS FOLLOWS:
@Override //
protected void finalize() throws Throwable
{
try{
……………….
} catch(Throwable t)
{
throw t;
}finally{ [Link]();
} }
Following points need to be taken into consideration when using finalize() method:
1. [Link]() method is always called in finalize() method.
2. Time critical application logic should not be placed in finalize() method.

4. Explain custom exceptions in Java and discuss when and why you would create your own
exception classes.
CUSTOM EXCEPTIONS IN JAVA

In Java, custom exceptions are user-defined exceptions that allow developers to represent specific
error conditions more descriptively than standard exceptions. Java’s built-in exceptions cover
many general error scenarios, such as NullPointerException or
ArrayIndexOutOfBoundsException. However, there are times when these general exceptions
don’t convey enough specific information about what went wrong in a given application context.
Custom exceptions can address this by providing more precise error messages and context,
tailored to the application's needs.
To create a custom exception, you extend either the Exception class (for checked exceptions) or the
RuntimeException class (for unchecked exceptions).

WHY AND WHEN TO USE CUSTOM EXCEPTIONS

Custom exceptions are valuable in situations where built-in exceptions are too generic or do not
provide adequate detail about the error condition. Here are some key scenarios:

1. Improving Code Readability: Custom exceptions make code more understandable by defining
specific error scenarios in meaningful terms. For instance, an exception named
InvalidAgeException clearly indicates an age-related issue, whereas a general
IllegalArgumentException might not be as descriptive.
2. Handling Specific Business Logic Errors: In applications with unique business rules, custom
exceptions can represent specific conditions. For example, in a banking system, an
InsufficientFundsException can be used to handle situations where a user attempts to withdraw
more money than they have in their account.
3. Creating Targeted Error Messages: With custom exceptions, you can provide detailed error
messages that can help developers or users better understand what went wrong and how to
address it.
4. Enhancing Exception Management: Using custom exceptions allows for more precise
handling of errors, as specific catch blocks can be created for each custom exception type, rather
than relying on generic exceptions.

HOW TO CREATE A CUSTOM EXCEPTION

To create a custom exception, define a class that extends either Exception (checked exception) or
RuntimeException (unchecked exception). Here is an example:

// Define a custom checked exception for insufficient funds

public class InsufficientFundsException extends Exception {
private double shortfall;

// Constructor with a message and additional context

public InsufficientFundsException(double shortfall) {
super("Insufficient funds: shortfall of " + shortfall + " units.");
[Link] = shortfall;
}

// Getter for the amount of shortfall

public double getShortfall() {
return shortfall;
}
}
In this example:

• The InsufficientFundsException is a checked exception that represents a custom error related to

insufficient funds.
• A shortfall field holds the shortage amount, which can be accessed via a getter method, making
it easy to retrieve additional context about the error.

EXAMPLE OF USING A CUSTOM EXCEPTION

Here’s how you might use the InsufficientFundsException in a banking application:

public class BankAccount {

private double balance;

public BankAccount(double balance) {

[Link] = balance;
}

// Method to withdraw an amount with custom exception

public void withdraw(double amount) throws InsufficientFundsException {
if (amount > balance) {
throw new InsufficientFundsException(amount - balance);
}
balance -= amount;
}

public double getBalance() {

return balance;
}
}

public class TestCustomException {

public static void main(String[] args) {
BankAccount account = new BankAccount(500.00);

try {
[Link](700.00);
} catch (InsufficientFundsException e) {
[Link]([Link]());
[Link]("Shortfall: " + [Link]());
}
}
}
In this code:

• The withdraw method checks if the withdrawal amount is greater than the balance. If it is, an
InsufficientFundsException is thrown, providing the amount of shortage.
• The catch block catches the custom exception and provides specific information to the user,
making it easier to diagnose the problem.

ADVANTAGES OF CUSTOM EXCEPTIONS

1. Clarity and Precision: Custom exceptions make code easier to understand by defining unique
error scenarios, which helps maintain code quality and readability.
2. Improved Debugging and Maintenance: With specific error messages and fields, custom
exceptions facilitate debugging and provide useful information during error handling.
3. Consistency in Error Handling: Custom exceptions standardize how specific errors are
managed across different parts of the application, making the codebase more maintainable.

4. Describe the process of handling multiple exceptions in Java with a single try block.
Include examples with multiple catch clauses,?

HANDLING MULTIPLE EXCEPTIONS IN JAVA WITH A SINGLE TRY BLOCK

In Java, multiple exceptions can be managed within a single try block by using multiple catch clauses.
This approach allows the developer to handle each exception type specifically and separately
within the same try structure, simplifying the code and making error handling more organized.
Each catch block handles a different exception type, which makes it easier to specify unique
recovery or logging logic based on the exception that occurs.

SYNTAX AND STRUCTURE

try {
// Code that may throw multiple exceptions
} catch (ExceptionType1 e1) {
// Code to handle ExceptionType1
} catch (ExceptionType2 e2) {
// Code to handle ExceptionType2
} catch (ExceptionTypeN eN) {
// Code to handle ExceptionTypeN
}

In this structure:

• try block: Contains code that might throw one or more types of exceptions.
• Multiple catch blocks: Each block catches a specific exception type. When an exception is
thrown, the first catch block that matches the exception type is executed, and the subsequent
catch blocks are skipped.

EXAMPLE WITH MULTIPLE CATCH CLAUSES

Let's consider an example where we perform an operation that might throw either an
ArithmeticException or an ArrayIndexOutOfBoundsException.

public class MultipleExceptionsExample {

public static void main(String[] args) {
int[] numbers = {1, 2, 3};

try {
int result = 10 / 0; // This line will throw ArithmeticException
[Link]("Array element: " + numbers[5]); // This line would throw
ArrayIndexOutOfBoundsException if reached
} catch (ArithmeticException e) {
[Link]("Arithmetic Exception: Division by zero is not allowed.");
} catch (ArrayIndexOutOfBoundsException e) {
[Link]("Array Index Out Of Bounds Exception: Invalid array index accessed.");
} catch (Exception e) {
[Link]("General Exception: An unexpected error occurred.");
}
}
}
EXPLANATION OF THE EXAMPLE:

1. ArithmeticException Catch Block: If a division by zero occurs, the ArithmeticException block

is executed, printing a relevant message.
2. ArrayIndexOutOfBoundsException Catch Block: If an invalid index is accessed, the
ArrayIndexOutOfBoundsException block handles it.
3. General Exception Block: If any other unexpected exception occurs, the final catch block for
Exception acts as a fallback to handle all other unanticipated exceptions.

This example helps ensure that specific error handling is provided for common issues, and a general
handler is in place for any other unexpected issues.

USING MULTI-CATCH BLOCK (JAVA 7 AND ABOVE)

Java 7 introduced a multi-catch feature, which allows a single catch block to handle multiple
exceptions by separating them with the pipe (|) symbol. This approach is useful when the
handling logic for different exceptions is the same.
public class MultiCatchExample {
public static void main(String[] args) {
int[] numbers = {1, 2, 3};

try {
int result = 10 / 0; // ArithmeticException
[Link]("Array element: " + numbers[5]); // ArrayIndexOutOfBoundsException
} catch (ArithmeticException | ArrayIndexOutOfBoundsException e) {
[Link]("Error: Either division by zero or invalid array index accessed.");
}
}
}
BENEFITS OF HANDLING MULTIPLE EXCEPTIONS IN A SINGLE TRY BLOCK

1. Organized Code: Using multiple catch blocks under one try block keeps error-handling code in
one place, making the structure cleaner.
2. Specific Error Messages: Each catch block can provide a unique message or action for each
exception type, making it easier to identify and resolve specific issues.
3. Flexibility with Multi-Catch: Java's multi-catch feature allows for consolidated handling when
the logic for different exceptions is identical, reducing redundancy in the code.

UNIT II: STRING HANDLING AND MULTITHREADING

SHORT ANSWER QUESTIONS

1. What is a string in Java?

A string in Java is a sequence of characters used to represent text. The String class in Java is
immutable, meaning that once a string object is created, its value cannot be changed. Strings are
created using double quotes, e.g., "Hello World", and Java provides a variety of methods in the
String class for string manipulation.

2. What does the StringBuffer class do?

The StringBuffer class in Java is used to create mutable (modifiable) strings. Unlike String,
StringBuffer allows modification of the string's content without creating a new object each time.
It provides methods for appending, inserting, and modifying strings efficiently, and it is
synchronized, making it thread-safe.

3. What is a thread in Java?

A thread in Java is a lightweight process within a program that can run concurrently with other
threads. Threads allow Java applications to perform multiple tasks simultaneously, making the
program more responsive. Java provides built-in support for multithreading through the
[Link] class and the Runnable interface.

4. How do you create a new thread in Java?

In Java, a new thread can be created in two main ways:
• By extending the Thread class: Create a subclass of Thread, override the run() method, and
then start the thread by calling start().
• By implementing the Runnable interface: Implement the Runnable interface, define the run()
method, and pass the Runnable object to a Thread object, then call start().

Example:

// Extending Thread class

class MyThread extends Thread {
public void run() {
[Link]("Thread running...");
}
}

// Implementing Runnable interface

class MyRunnable implements Runnable {
public void run() {
[Link]("Runnable thread running...");
}
}

5. What is the difference between synchronized and non-synchronized methods in Java?

• Synchronized Method: A synchronized method in Java is one that is thread-safe, meaning that
only one thread can access the method at a time. This prevents data inconsistency when multiple
threads attempt to modify shared data concurrently. To make a method synchronized, you use
the synchronized keyword.
• Non-Synchronized Method: A non-synchronized method does not have thread safety, meaning
multiple threads can access it simultaneously. This can lead to issues when threads are
modifying shared data, as changes from one thread may interfere with another's, leading to
unexpected behavior.

1. Discuss the differences between String, StringBuffer, and StringBuilder classes in Java.
Provide examples.

In Java, String, StringBuffer, and StringBuilder are classes used to handle and manipulate strings, but
they differ in mutability, performance, and thread safety.

• String:
o Immutable: Once a String object is created, it cannot be modified. Any change results in the
creation of a new String object.
o Thread-Safe: Because String is immutable, it is inherently thread-safe.
o Performance: Since strings are immutable, frequent modifications can create many new objects,
leading to higher memory usage and slower performance.

Example:

String str = "Hello";

str = str + " World"; // New String object created

• StringBuffer:
o Mutable: StringBuffer allows modification of the string’s content without creating a new object,
making it efficient for frequent modifications.
o Thread-Safe: All methods in StringBuffer are synchronized, meaning only one thread can
modify a StringBuffer object at a time.
o Performance: Although thread-safe, StringBuffer can be slower than StringBuilder due to
synchronization overhead.

Example:

StringBuffer sb = new StringBuffer("Hello");

[Link](" World"); // Modifies the original object

• StringBuilder:
o Mutable: Like StringBuffer, StringBuilder is mutable and allows string modification without
creating new objects.
o Not Thread-Safe: StringBuilder methods are not synchronized, making it faster but unsuitable
for concurrent use by multiple threads.
o Performance: Generally faster than StringBuffer due to the absence of synchronization.

Example:

StringBuilder sb = new StringBuilder("Hello");

[Link](" World"); // Modifies the original object

EXAMPLE PROGRAM :

public class StringExample {

public static void main(String[] args) {
// Example with String (Immutable)
String str = "Hello";
str = str + " World"; // Creates a new String object since String is immutable
[Link]("String example: " + str); // Output: Hello World

// Example with StringBuffer (Mutable and Thread-Safe)

StringBuffer stringBuffer = new StringBuffer("Hello");
[Link](" World"); // Modifies the original StringBuffer object
[Link]("StringBuffer example: " + stringBuffer); // Output: Hello World

// Example with StringBuilder (Mutable but Not Thread-Safe)

StringBuilder stringBuilder = new StringBuilder("Hello");
[Link](" World"); // Modifies the original StringBuilder object
[Link]("StringBuilder example: " + stringBuilder); // Output: Hello World
}

3. Describe the lifecycle of a thread in Java, explaining the different states a thread can be in.
1. THREAD STATES
Thread states are as follows.
i. New thread state
ii. Ready-to-run state
iii. Running state
iv. Non-runnable state-waiting, sleeping, or blocked state
v. Dead state

The following Figure illustrates the different states of a [Link] transition from one state to another
is shown in the figure. The different states are as follows

1. New thread state. The thread is just created. It is simply a lifeless object of class Thread.
2. Runnable state: When the thread invokes the method start(), it becomes alive. This state is
called runnable state. It is not a running state. It is simply a ready-to-run. The thread has to
wait till it is scheduled, that is, selected from the group of threads waiting in running state for
dispatch to the CPU by the scheduler
3 Running state. If the scheduler chooses the thread from the waiting list of threads and dispatches
it CPU, the thread transits to runnable state, that is, it starts executing the method run() meant
for it. This is turning state. If it completes its run() method successfully, its life span is over.
The thread is automatically terminated and it goes to dead state from which it cannot be
revived.
4. Sleep state: The code that a thread is executing may require it to relinquish the CPU for
sometime so the other threads can possess CPU. The sleep method may be invoked by the
thread. The time period of them is the argument of sleep() method. It is either long
 milliseconds
or int nanoseconds. After the sleep the thread returns normally to runnable state.
5. Blocked state. A running thread gets into blocked state if it attempts to execute a task.
6. State wait: A thread gets into wait state on invocation of any of the three methods wait() or
wait (long millisees) or wait (long millisecs, int nanosecs).
7. yield. The use of code Thread yield(), is another method besides the sleep for the thread to
cease the use of CPU. The thread transits to Runnable state.
8. Suspended. The term belongs to legacy code and is defined in Java 1.1. The suspended thread
can be brought back to normal Runnable state only by method resume(). Both the methods
suspend() and
resume() are now deprecated, instead one should use wait()and notify().

3. Explain thread synchronization in Java and discuss the role of the synchronized keyword
with examples.
WHAT IS THREAD SYNCHRONIZATION?

Thread synchronization is a mechanism in Java used to control access to shared resources by multiple
threads. When multiple threads try to access and modify the same resource (like a variable, file,
or database), there is a risk of data inconsistency or race conditions. Thread synchronization
ensures that only one thread can access a critical section of code at a time, preserving data
integrity and consistency.

synchronized keyword:

1. Definition of Thread Synchronization:

o Thread synchronization is a mechanism to control access to shared resources in a multithreaded
environment to ensure data consistency and avoid race conditions.
2. Need for Synchronization:
o When multiple threads access shared resources simultaneously (e.g., shared variables, files), data
inconsistency may occur without synchronization.
o Synchronization ensures only one thread accesses critical sections at a time, preserving data
integrity.
3. Role of the synchronized Keyword:
o Used to restrict a method or a code block so that only one thread can execute it at any given
time.
o It allows the thread to acquire a lock on the object or class and prevents other threads from
entering any synchronized method/block until the lock is released.
4. Types of Synchronization:
o Method Synchronization: Locks the entire method, allowing only one thread to execute the
synchronized method at a time.
o Block Synchronization: Synchronizes only a specific part of a method, allowing greater
efficiency by locking only the critical section rather than the entire method.
5. Examples:
o Method Synchronization Example: Using a synchronized method to increment a counter.
o Block Synchronization Example: Synchronizing a specific block within a method for better
performance.
6. Static Synchronization (Class-Level Locking):
o Synchronizing static methods involves locking the Class object itself rather than individual
instances.
o Useful when shared data is accessed through static methods, ensuring only one thread accesses
the method at a time.
7. Important Points about the synchronized Keyword:
o Object Lock: Synchronization locks the object for instance methods and the class object for
static methods.
o Atomicity and Thread Safety: Ensures that operations in the synchronized block/method are
atomic and safe from concurrent access.
o Deadlocks: Improper synchronization may lead to deadlocks if multiple threads are waiting for
each other’s resources.
8. Advantages of Synchronization:
o Ensures data consistency and prevents race conditions.
o Provides atomic operations on shared resources, maintaining thread safety.
9. Disadvantages of Synchronization:
o Performance overhead due to locking mechanisms.
o Deadlock risks if synchronization is not managed properly.
o Increased complexity in multithreaded program design.

[Link] inter-thread communication in Java, discussing methods like wait () , notify (), and
notifyAll ( ) with examples. ?
INTER-THREAD COMMUNICATION IN JAVA

Inter-thread communication is a mechanism that allows threads to communicate with each other. In
Java, threads can work together by using methods like wait(), notify(), and notifyAll(), which are
defined in the Object class. These methods are essential for situations where one thread needs to
wait for another thread to complete a task before continuing its execution.

Java’s built-in mechanism for inter-thread communication is based on the concept of monitors (locks)
and condition variables. The basic idea is that threads can signal each other when certain
conditions are met.

METHODS FOR INTER-THREAD COMMUNICATION

1. wait():
o The wait() method is used by a thread to release the lock it holds and enter the waiting state. The
thread remains in the waiting state until it is awakened by another thread.
o It must be called from a synchronized block or method because a thread must hold a lock to call
wait().
2. notify():
o The notify() method wakes up one thread that is waiting on the object’s monitor. The awakened
thread will attempt to acquire the lock, but it can only proceed once it has successfully acquired
the lock.
o This method is also used within a synchronized block or method.
3. notifyAll():
o The notifyAll() method wakes up all threads that are waiting on the object's monitor.
o Like notify(), it must also be called from within a synchronized block or method.

These methods are generally used in scenarios like producer-consumer problems, where one thread
produces data and another consumes it.

EXAMPLE: PRODUCER-CONSUMER PROBLEM

In the producer-consumer problem, one thread (the producer) generates data and places it in a shared
buffer, while another thread (the consumer) takes data from the buffer. The wait() and notify()
methods can be used to coordinate the interaction between these threads.

class SharedBuffer {
private int data;
private boolean available = false; // Shared resource

// Producer thread will call this method to produce data

public synchronized void produce(int data) throws InterruptedException {
while (available) {
wait(); // Wait if the data is already available
}
[Link] = data;
[Link]("Produced: " + data);
available = true;
notify(); // Notify the consumer that data is available
}

// Consumer thread will call this method to consume data

public synchronized int consume() throws InterruptedException {
while (!available) {
wait(); // Wait if no data is available to consume
}
[Link]("Consumed: " + data);
available = false;
notify(); // Notify the producer that the buffer is empty
return data;
}
}
public class ProducerConsumerExample {
public static void main(String[] args) {
SharedBuffer buffer = new SharedBuffer();

// Producer thread
Thread producer = new Thread(() -> {
try {
for (int i = 1; i <= 5; i++) {
[Link](i);
[Link](1000); // Simulate time taken to produce data
}
} catch (InterruptedException e) {
[Link]();
}
});

// Consumer thread
Thread consumer = new Thread(() -> {
try {
for (int i = 1; i <= 5; i++) {
[Link]();
[Link](1500); // Simulate time taken to consume data
}
} catch (InterruptedException e) {
[Link]();
}
});

[Link]();
[Link]();
}
}
EXPLANATION OF THE EXAMPLE

1. SharedBuffer Class:
o The SharedBuffer class simulates the shared resource between the producer and consumer.
o The produce() method simulates producing data and placing it in the buffer. If the data is already
available (available = true), the producer will wait by calling wait().
o The consume() method simulates consuming the data. If no data is available (available = false),
the consumer will wait.
2. Producer-Consumer Coordination:
o When the producer produces data, it notifies the consumer that data is available by calling
notify().
o When the consumer consumes the data, it notifies the producer that the buffer is empty and it
can produce more data.
3. Thread Coordination:
o The wait() method is used to make the producer wait if the buffer is full, or make the consumer
wait if the buffer is empty.
o The notify() method wakes up the waiting thread, allowing either the producer or consumer to
proceed.

DETAILED BEHAVIOR

• Producer: When the producer thread produces data, it checks if the buffer is full (available ==
true). If it is, it calls wait(), releasing the lock and allowing the consumer to consume data. Once
it produces data, it calls notify() to wake up the consumer.
• Consumer: The consumer thread checks if there is data to consume (available == false). If not,
it calls wait(), releasing the lock and allowing the producer to produce new data. Once it
consumes the data, it calls notify() to wake up the producer.

DIFFERENCES BETWEEN NOTIFY() AND NOTIFYALL()

• notify(): Wakes up only one thread that is waiting on the object’s monitor. If multiple threads
are waiting, it is uncertain which thread will be woken up.
• notifyAll(): Wakes up all threads that are waiting on the object’s monitor. This is useful when
multiple threads are waiting for a condition to be satisfied.

EXAMPLE WITH NOTIFYALL()

class SharedResource {
public synchronized void printMessage(String message) {
[Link](message);
notifyAll(); // Notify all threads waiting on this object
}
}

public class NotifyAllExample {

public static void main(String[] args) {
SharedResource resource = new SharedResource();

// Create three threads that call printMessage

for (int i = 1; i <= 3; i++) {
int threadNum = i;
new Thread(() -> {
synchronized (resource) {
try {
[Link]("Thread " + threadNum + " is waiting.");
[Link](); // Wait until notified
[Link]("Thread " + threadNum + " has finished.");
} catch (InterruptedException e) {
[Link]();
}
}
}).start();
}
}
}

Explanation:

• All three threads print a message and then call wait() to wait for the notifyAll() signal.
• After the notifyAll() method is called, all threads are awakened, and they print the "finished"
message.

KEY POINTS ABOUT WAIT(), NOTIFY(), AND NOTIFYALL():

• wait(): Causes the current thread to release the lock and wait until it is notified.
• notify(): Wakes up one thread that is waiting on the object’s monitor.
• notifyAll(): Wakes up all threads that are waiting on the object’s monitor.
• . Explain deadlock and race conditions in multithreading. Discuss strategies to avoid deadlock in
Java applications.
[Link] deadlock and race conditions in multithreading. Discuss strategies to avoid deadlock
in Java applications.

DEADLOCK AND RACE CONDITIONS IN MULTITHREADING

DEADLOCK IN MULTITHREADING

A deadlock occurs in a multithreaded environment when two or more threads are blocked forever,
waiting for each other to release resources they need to proceed. It is a situation where a group
of threads are unable to make any progress because each thread is waiting for another to release
a resource, and none of the threads ever releases the resource they hold.

Deadlock typically occurs when the following four conditions are met:

1. Mutual Exclusion: At least one resource must be held in a non-shareable mode (i.e., only one
thread can hold the resource at a time).
2. Hold and Wait: A thread holding at least one resource is waiting to acquire additional resources
held by other threads.
3. No Preemption: A resource cannot be forcibly taken from a thread holding it; it must be
released voluntarily.
4. Circular Wait: A circular chain of threads exists where each thread holds at least one resource
and is waiting for a resource held by the next thread in the chain.

EXAMPLE OF DEADLOCK
class A {
synchronized void methodA(B b) {
[Link]("Thread 1: Holding lock A...");
try { [Link](100); } catch (Exception e) {}
[Link]("Thread 1: Waiting for lock B...");
[Link]();
}

synchronized void last() {

[Link]("Inside A's last method");
}
}

class B {
synchronized void methodB(A a) {
[Link]("Thread 2: Holding lock B...");
try { [Link](100); } catch (Exception e) {}
[Link]("Thread 2: Waiting for lock A...");
[Link]();
}

synchronized void last() {

[Link]("Inside B's last method");
}
}

public class DeadlockExample {

public static void main(String[] args) {
final A a = new A();
final B b = new B();

// Thread 1
new Thread() {
public void run() {
[Link](b);
}
}.start();
// Thread 2
new Thread() {
public void run() {
[Link](a);
}
}.start();
}
}

Explanation:

• Thread 1 holds the lock on object A and waits for the lock on object B, while thread 2 holds the
lock on object B and waits for the lock on object A.
• This creates a circular wait situation, leading to deadlock.

RACE CONDITIONS IN MULTITHREADING

A race condition occurs when two or more threads attempt to update a shared resource concurrently,
and the final result depends on the order in which the threads execute. Since threads are
executed concurrently, the behavior is unpredictable, and data inconsistencies may arise.

Example of a Race Condition:

class Counter {
private int count = 0;

// Method that increments count

public void increment() {
count++;
}

public int getCount() {

return count;
}
}

public class RaceConditionExample {

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

// Create 1000 threads that increment the counter

Thread t1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
[Link]();
}
});

Thread t2 = new Thread(() -> {

for (int i = 0; i < 1000; i++) {
[Link]();
}
});

[Link]();
[Link]();

[Link]();
[Link]();

[Link]("Final Count: " + [Link]());

}
}

Explanation:

• The count variable is shared by two threads. Each thread increments the counter 1000 times.
• Without synchronization, both threads may read and update the count variable at the same time,
causing incorrect results due to concurrent access, leading to a race condition.
• The expected output is 2000, but due to the race condition, it might be a lower number because
both threads are not properly synchronized.

STRATEGIES TO AVOID DEADLOCK IN JAVA APPLICATIONS

1. Avoid Nested Locks:

o Avoid acquiring more than one lock at a time, as it increases the chances of creating circular
dependencies. If multiple locks are necessary, ensure they are always acquired in a fixed order.
2. Lock Ordering (Fixed Order of Lock Acquisition):
o When multiple locks are needed, acquire them in a specific, consistent order across all threads.
This prevents circular waiting, which is one of the conditions for deadlock.
o Example: Always acquire lock1 before lock2.

java
Copy code
synchronized(lock1) {
synchronized(lock2) {
// critical section
}
}
3. Use Timeout for Lock Acquisition:
o Use ReentrantLock (from [Link] package) and its tryLock() method with a
timeout. This allows a thread to attempt to acquire the lock and, if unsuccessful after a certain
time, release the locks and retry, instead of waiting indefinitely.

java
Copy code
ReentrantLock lock1 = new ReentrantLock();
ReentrantLock lock2 = new ReentrantLock();

if ([Link]() && [Link]()) {

try {
// critical section
} finally {
[Link]();
[Link]();
}
} else {
// Retry logic or exit
}

4. Use Higher-Level Concurrency Utilities:

o Java provides high-level concurrency utilities in the [Link] package, such as
ExecutorService, Semaphore, CountDownLatch, and CyclicBarrier. These abstractions help
manage complex thread coordination and reduce the likelihood of deadlocks.
5. Deadlock Detection:
o Some Java environments provide tools for detecting deadlocks, such as the Java VisualVM or
using the ThreadMXBean API to check for thread deadlocks at runtime. It is a good practice to
detect and resolve deadlocks during development and testing phases.
6. Use synchronized and ReentrantLock Properly:
o The synchronized keyword ensures that only one thread can execute a block of code at a time.
However, misuse of it in the context of multiple locks can cause deadlock.
o If using ReentrantLock, ensure proper unlocking in the finally block to avoid leaving locks in a
locked state.
7. Implement Lock Hierarchy:
o Establish a strict order in which resources should be locked, and follow that order consistently in
all threads. This way, deadlocks caused by circular waiting can be avoided.