HARSH JANARDAN JAGADALE

2314510500
Programming in Java

Q1. Java is a widely used, object-oriented programming language with the features of easy
implementation, easy portability and easy security. Here are five key features of Java:
Object-Oriented Programming (OOP): Java is implemented as the object-oriented
programming concept, i.e., coding programmatically so that program structure is into objects.
Resulting in greater modularity with easy maintenance of Java programs. Of the four
fundamental concepts of OOP (encapsulation, inheritance, polymorphism and abstraction) [d.
In Java, these concepts are utilized to construct extensible and refactors codes architectures.
Encapsulation is defined as the hiding of the internal state of an object, inheritance is the
process of transferring characteristics and behaviour of a class to a different one,
polymorphism is the process of allowing objects to seem as instance of a parent class, and
abstraction constitute the process by which intricate system appear simple by exposing a
particular aspect only of the system.
Platform Independence (Write Once, Run Anywhere): The most obvious advantage of Java is
platform independence. Java code is generated and compiled to bytecode (java virtual
machine (JVM) executes bytecode) . That is, the same Java code can be executed on any
system having a Java Virtual Machine (JVM) installed, with no matter what the underlying
hardware or the system of operation is. Therefore, Java is a highly portable language, i.e., a
developer can write the same code using a bare system and see it in operation on any
platform, e.g., Windows, Mac or Linux.
Automatic Memory Management (Garbage Collection): In the case of Java, there is an
implicit memory management module, which takes care of the memory management of
objects at run time. The garbage collector is responsible for unloading objects and freeing up
memory, throwing away and releasing objects, which are no longer being used by the
memory. This process helps in preventing memory leak, and yields a better overall
performance of the application. Compared with languages, like C or C+, in which
programmer need to consider manually memory allocation and memory deallocation, the
memory management of java is done automatically, so programmers in java do need to worry
less about memory allocation.
Multithreading Support: Java has built-in support for multiple threads, i.e., the concurrent
execution of a running thread within the same program. This function is crucial in order that
it be possible to perform multiple tasks concurrently, such as downloading of a file, receipt of
user input or simultaneous handling of requests by a server. Multithreading enhances the
performance and responsiveness of applications, particularly in scenarios where concurrency
is desired. Java provides a potent multithreading model using the Thread class and interfaces
such as Runnable, which enable parallel processing to be carried out by the programmer.
Rich API (Application Programming Interface): Java offers a comprehensive standard library
known as the Java API, which provides a wide range of pre-built classes and functions that
can be used to perform common tasks, such as working with data structures, handling file
input/output, networking, and creating graphical user interfaces. The Java API saves
programmers time and effort because* it gives ready-made solutions to a majority of
programming tasks. The library is constantly extended with some new capabilities and
enhancements, so that Java is a rich language for many different purposes.
These characteristics confer to Java a high power, robustness and adaptability, that is the
reason why it has been widely used for web applications, mobile applications, enterprise
application software, and embedded systems.

Q2. In Java, operators are symbols that perform operations on variables and values. They can
be classified into several types: arithmetic, relational, logical, assignment, bitwise, and unary
operators.
1. Arithmetic Operators
These operators perform basic mathematical operations: These operators perform basic
mathematical operations:
- (Addition): Adds two operands.
- (Subtraction): Subtracts the right operand from the left.
- (Multiplication): Multiplies two operands.
- (Division): Divides the left operand by the right.
- (Modulus): Returns the remainder of division.
These operators are used in calculations.
2. Relational (Comparison) Operators
Relational operators compare two values, returning a boolean result:
- (Equal to): Checks if operands are equal.
- (Not equal to): Checks if operands are not equal.
- (Greater than): Tests whether the left operand is larger than the right.
- (Less than): Verify that left operand is less than right operand.
Checks if the left operand is greater or equal.
Checks if the left operand is less or equal.
These are used in decision-making statements.
3. Logical Operators
Logical operators combine boolean expressions: Logical operators combine boolean
expressions:
- (AND): Returns if both operands are true.
- (OR): Returns if at least one operand is true.
- (NOT): Reverses the boolean value.
Conditional statements for combining several conditions, they are normally used.
4. Assignment Operators
Assignment operators assign values to variables: Assignment operators assign values to
variables:
- (Simple Assignment): Assigns the right operand to the left.
- (Add and Assign): This statement performs left addition on the right operand and assigns
the sum to the left.
- (Subtract and Assign): Subtracts the right operand from the left and stores the result.
- (Multiply and Assign): Multiplies the left by the right operand and assigns the result.
- (Divide and Assign): Splits the left operand by the right operand and saves the result.
- (Modulus and Assign): Assigns the remainder of division.
These operators simplify expressions combining arithmetic and assignment.
5. Bitwise Operators
Bitwise operators manipulate the individual bits of integers:
- (AND): Performs bitwise AND.
- (OR): Performs bitwise OR.
- (XOR): Performs bitwise XOR.
- (NOT): Inverts the bits.
- (Left Shift): Shifts bits to the left.
- (Right Shift): Shifts bits to the right.
- (Unsigned Right Shift): Shifts bits right, filling zeros.
These operators are applicable for low-level programming and binary data manipulation.
6. Unary Operators
Unary operators act on a single operand:
- (Unary Plus): Indicates a positive value.
- (Unary Minus): Negates the value of the operand.
- (Increment): Increases the operand by 1.
- (Decrement): Decreases the operand by 1.
- (Logical NOT): Reverses the boolean value.
These operators are used for basic operations, such as incrementing or negating values.
7. Ternary Operator
The ternary operator is an abbreviation for an conditional expression. It takes three operands:
It provides a concise way to perform conditional assignments.
8. Instanceof Operator
The operator tests whether an object is an instance of a specific class or implements an
interface:.
It takes as argument a type and returns if the object is of the given type and otherwise.

Q3. An array in Java is a data type which enables you to hold multiple values of the same
data type in a single variable. Arrays are utilized whenever you have to store an assortment of
elements like numbers, strings, or objects, and these elements are accessible using a single
reference variable. The elements of an array are held in a single block of memory, and every
element can be accessed based on its index, which is zero-based.
Declaring an Array
An array can be declared in Java in two ways:
1. With specific size: When you declare an array, you have to specify how many elements it
will hold, which determines its size. For instance, an array of integers with 5 elements can be
declared as follows:
int[] arr = new int[5];
Here, the array `arr` can store 5 integer values. The array size is declared using the `new`
keyword and the type of elements (`int` here) and the number of elements the array will store.
2. With initialization: An array can also be initialized with values during declaration. For
instance:
int[] arr = {1, 2, 3, 4, 5};
Here, array `arr` is defined with 5 elements and size gets automatically decided as per the
number of elements used for initialization.
Accessing Array Elements
In Java, elements of an array are referenced by indices, and the index of the first element is 0.
For instance, let's take the following array:
int[] arr = {10, 20, 30, 40, 50};
To get access to the first element of the array, we use the index `0`
System.out.println(arr[0]); // Prints 10
Similarly, to access the last element, we use the index `4`:
System.out.println(arr[4]); // Outputs 50
Array Length
The size of an array in Java is specified by the `length` property. The property is the number
of elements that the array can store, but it is not a method, and therefore it is accessed without
the use of parentheses. For instance:
System.out.println(arr.length); // Prints 5
This will output `5`, since the array has five elements.
Multidimensional Arrays
Apart from one-dimensional arrays, Java also provides multidimensional arrays, e.g., two-
dimensional arrays, which can be thought of as arrays of arrays. A two-dimensional array can
be declared as:
int[][] matrix = new int[3][3];
Here, `matrix` is a two-dimensional array with 3 rows and 3 columns. To initialize it with
values:
int[][] matrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
To reference an element in a two-dimensional array, you have two indices: one for the row
and one for the column:
System.out.println(matrix[1][2]); // Prints 6
Example: Using Arrays
Suppose we have an array to hold the marks of 5 students in a class and want to find the
average score:
public class ArrayExample {
public static void main(String[] args) {
int[] marks = {85, 90, 78, 92, 88};
int sum = 0;
for (int i = 0; i < marks.length; i++)
sum += marks[i];
}
double average = sum / (double) marks.length;
System.out.println("Average marks: " + average);
}
}
In this case:
- A 5 student marks array `marks` is initialized.
- A for loop is used to compute the sum of all the marks.
- Lastly, the average is obtained by dividing the total by the size of the array.
Advantages of Using Arrays
Arrays provide several advantages in programming:
1. Efficiency: Arrays provide efficient access to elements via indices.
2. Memory management: Arrays store elements in contiguous memory locations, which can
improve memory access times.
3. Easy to use: Arrays make it easy to iterate and manipulate sets of data.
Yet, Java arrays have a few constraints, including fixed size, i.e., once an array is declared, its
size cannot be dynamically altered. That is why other data structures like ArrayLists
are employed if the collection size may change.

Q4. Errors and exceptions are both issues in Java that arise at the time of the execution of a
program, but they have different characteristics and are handled differently.
Errors
Errors in Java are typically problems that arise from the environment in which the program is
running. They are serious problems which are hard to recover after application. Errors are
serious problems that are not under the control of the program. These problems are typically
associated with system-wise resources and the environment, like memory, hardware, or JVM-
related issues.
In Java, errors are instances of the class, which is a subclass of the class. Errors are generally
not caught or dealt with by programs, as they are not expected to be caught. They also
describe situations that are nearly always lethal, and recovery from such situations is usually
not possible. Some common examples of errors are:
- OutOfMemoryError: Occurs when the JVM runs out of memory.
- StackOverflowError: Happens when the stack expands too far, usually due to too much
recursion.
- InternalError: Internal JVM issues that are not the control of the program.
Because errors are important and the majority of them stem from system-level failures, errors
in Java programs are not anticipated to be caught or handled by the program. When an error
occurs, it normally leads to the program terminating.
Exceptions
Exceptions, however, are disturbances to the serial execution of a program that may be dealt
with by the program itself. Exceptions are used to describe situations that are commonly
caused by user input, illegal operations, or programming errors. Java distinguishes between
two main types of exceptions:
1. Checked Exceptions: These exceptions are explicitly checked at compile-time. If a method
is declared to throw an unchecked exception, the method calling it must account for it with a
block or declare it with the keyword. Checked exceptions are typically used for recoverable
conditions. Examples of a checked exception are that happen when an I/O operation fails.
2. Unchecked Exceptions: These exceptions/runtime exceptions are checked at runtime, and
will not be checked at compile-time. Unchecked exceptions are typically errors in
programming, including logic errors or incorrect input. They are subtypes of and as they are
not mandatory to catch, they are not always explicitly caught. Examples of unchecked
exceptions include , , and .
Key Differences Between Errors and Exceptions
1. Nature of Problem:
Errors are usually due to outside factors such as lack of system resources or JVM errors,
which are forces that cannot be controlled by the program.
There are often exceptions due to events occurring at the time of program execution, like an
incorrect user input, division by zero, or a file not found.
2. Recoverability:
Mistakes are generally not amendable, and the program lacks capabilities to correct it. They
often lead to the termination of the program.
- Exceptions are designed to be recoverable. It is possible from programs to trap exceptions
by means of the blocks, and appropriate actions are taken to address/recover from such
exceptions.
3. Handling:
Errors should not be caught or processed by the application. They indicate serious issues that
usually require termination.
Faults can be caught and processed by the program. In Java, the scheme permits a program to
handle exceptions and recover from them.
4. Hierarchy:
An error is an occurrence of the class, the direct subclass of.
Exceptions are instances of the class, which is a subclass of. The exceptions can also be
classified into checked (subclass of and unchecked (subclass of scenarios.
5. Examples:
- Errors: OutOfMemoryError, StackOverflowError.
- Exceptions: IOException, NullPointerException, ArithmeticException.

Q5. Synchronization of threads in Java is a technique that guarantees that two or more
threads can never read shared resources concurrently in a manner that leads to inconsistent
state. If more than one thread is writing to the same shared data or resource simultaneously,
there is a potential for loss of data integrity or discrepancy of data caused by reading out and
modifying it at the same time. Synchronization addresses this problem by regulating the
access to the common resource, allowing access to the resource to the only thread at a time.
Why Synchronization is Necessary
In a multithreaded world, if more than one thread executes at the same time, they can all try
to change common resources (variables or data structures) simultaneously. This can lead to
unpredictable behavior and bugs that are difficult to track down. For instance, when two
threads want to modify a shared variable at the same time, one of the changes might be lost,
and therefore, the result might be flawed. In order to avoid such problems synchronization is
employed to assure that exactly one thread is allowed to access the critical section (the
section of code that accesses to the shared resource) at a time.
How Synchronization Works
Synchronization in Java is provided by the keyword, which can be applied to either methods
or blocks of code. If a method, block or another process is executed synchronously, the thread
acquires a lock on the resource the operation is b bering done with. This lock prevents other
threads from accessing synchronized code units associated with the same resource.
There are two main approaches for synchronizing threads in Java:
1. Synchronized Methods:
A method can be synchronized by the introduction of the synchronized keyword in its
declaration. If a method is synchronized, the current thread acquires a lock on the object
calling the method. In this way, there is at the same time no other thread able to run any
synchronized method on the same object. For example:
public void increment() {
synchronized (this) {
count++;
}
In this example, the increment() method is synchronized. If one thread is running this
method, other threads trying to invoke this method on the same object will have to wait until
the lock is released.
2. Synchronized Blocks:
There are occasions when it is not required to synchronise, specifically, a specific part of a
method, instead of the whole method. This can be done using synchronized blocks. In this
case, you specify an object on which the thread will acquire a lock, ensuring that only one
thread can execute the synchronized block at a time. For example:
public void increment() {
synchronized (this) {
count++;
}
}
Types of Locks
If synchronization is applied, the lock is linked to the object in which the synchronized
method or block is called. The two types of locks in Java are:
1. Instance Lock: The lock is related to the object instance for concurrent instance methods.
The execution of synchronized methods in parallel by different threads of execution on
different instances of the same class is not interfered with.
2. Class Lock: Synchronized static methods are associated with the lock of the class itself.
This indicates that when several threads are writing to a synchronized static method, blocking
may occur, even when also several threads are accessing different instances of the same class.
Deadlock in Synchronization
Although synchronization is essential to ensure the consistency of data, synchronization can
result in a situation called deadlock. Deadlock happens when two or more threads are stuck
due to each other to be freed from locks, so no threads can be further execution. For instance,
when Thread 1 holds Resource A and goes into a Wait state and resource B, while Thread 2
holds Resource B and goes into a Wait state and resource A, both threads may be stuck,
causing a deadlock. For deadlock prevention, it is highly desirable to have a careful design as
far as synchronization is concerned, e.g., acquire locks in a fixed sequence, etc.

Q6. The lifecycle of a servlet in Java is the execution sequence as it is started to be ended,
from the servlet being first created (instance) to finally being eliminated (destroyed). A
servlet is a server-side Java program for making reductions on a request and generating a
response, which is often employed in the development of web-based dynamically changing
application programs. The life cycle of a servlet is managed by the servlet container, a
component that is built into the web server or the application server. The container handles
servlet initialization, request processing, and cleanup, initialization, request handling, and
termination.
1. Initialization Phase
In the initialization phase, the servlet server is placed in a memory space, which is provided
by the servlet container. At this stage the servlet is available, in order to process client
requests. In this phase, the init( method is executed and performed only at the beginning of
the life cycle of a servlet.
When is the init() Method Called
The init( method is called either at first access of the servlet to the client, or at that of the
server, according to the configuration of the servlet on the web.xml` or by the annotations).
Purpose of the init() Method:
The one-shot setup function is implemented by the function `init(, e.g., prepare resources,
establish database link, or set up configuration parameter.
Example: -
public void init(ServletConfig config) throws ServletException {
super.init(config);
System.out.println("Servlet initialized");
}
2. Request Handling Phase
In the initialization phase, the servlet runs under the request handling phase, which is longest
term of its life. At this point the servlet passes on the client request and returns the
appropriate response. This is also done by the `service(method, which is the function which is
invoked by the servlet container every time a request is made.
How the service() Method Works: - How the service() Method Works:
The service( method specifies which kind of request (e.g., GET, POST) is made by invoking
the corresponding method, i.e., doGet( or `doPost(. For example:
doGet(): Handles HTTP GET requests.
doPost(): Handles HTTP POST requests.
Request Handling Workflow: - Request Handling Workflow:
1. The client sends an HTTP request to the server.
2. The following request is addressed to the servlet's detail and this is resolved within
the servlet container.
3. On the basis of the request type, the corresponding method (e.g., doGet(, doPost(, etc.
is invoked.
Example: -
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
response.getWriter().println("Handling GET request");
}
In this step the following operations can also be carried out, for example reading client
information, query of database and generation of an HTML or JSON response.
3. Termination Phase
The cleanup stage, occurring when the servlet is no longer running, for example, after the
server has been shut down or the servlet is explicitly unloaded. In this phase the servlet
container implements the `destroy( method.
Purpose of the destroy() Method: - Purpose of the destroy() Method:
The `destroy( (method is used to clear the resources which were obtained during the lifecycle
of the servlet, for example, to close the database connections, to stop the background threads,
or to clean up the temporary files).
When is the destroy() Method Called?
The destroy (the method is invoked only once and just before the servlet is ejected from
memory.
Example: -
public void destroy() {
System.out.println("Servlet is being destroyed");
}
Additional Notes on Servlet Life Cycle
Thread Handling: - Thread Handling:
In the case of a servlet container, one instance of a servlet is usually instantiated and requests
are served through multiple threads. It is an indication that the `service (routine is not thread-
safe, i.e., it might lead to issues with mutual exclusive resources.
Servlet Lifecycle Methods in the javax.servlet API:
init(): Called once for initialization.
service(): Called multiple times to handle client requests.
destroy(): Called once for cleanup.
Lifecycle Management: - Lifecycle Management:
The container servlet perspective has the consequence that the container servlet has complete
control and ownership, of the servlet lifecycle and that the servlet will be properly launched,
serve requests as fast as possible and be garbage collected the moment it is no longer used.
This frees the developer to focus on application logic alone and not on low-level lifecycle
management.
In a nutshell, the servlet life cycle is managed by initialization using init( together with
request processing via service( and the interaction with the associated HTTP-derivable
methods, respectively, and termination by `destroy(. In this phase the servlets are tuned for
performance and for the responsiveness of client requests, and the resource allocation is also
satisfactory.