MANIPAL UNIVERSITY, JAIPUR

INTERNAL ASSIGNMENT

STUDENT NAME MOHD ARMAN

ROLL NO. 2314512248
SESSION NOV-DEC 2024
PROGRAM MASTER OF COMPUTER APPLICATIONS (MCA)
SEMESTER 3
COURSE CODE & NAME DCA7102- PROGRAMMING IN JAVA
CREDITS 4
NUMBER OF ASSIGNMENTS & 02
MARKS 30

SET I

Q. No1 Explain any five features of Java.

Ans: five Key features of Java

Java is one of the most famous programmintegratedg languages, widely used for built-
inintegrated programs built-in corporation software program to cellular apps and built-in
applications. it's miles an item-orientated, platform-impartial, and relatively at ease language.
built-in are five of its most critical functions:
1. Platform Independence
one of the most huge advantages of Java is its platform built-independence. which means Java
applications can run on one-of-a-kbuiltintegrated built-in systems with out requirintegratedg
adjustments. that is done via the Java virtual built-indevice (JVM), which allows Java bytecode
to be done on any system that has a compatible JVM. The built-inprbuiltintegrated "Write once,
Run anywhere" (WORA) defbuilt-ines this feature, makbuilt-ing Java a preferred desire for
cross-platform improvement. developers can write Java code on home wbuiltintegrated, built-
ing together it built-into bytecode, and run the same software on Lbuilt-inux, macOS, or every
other machbuiltintegrated with a JVM established.

2. object-oriented Programmintegratedg (OOP)

Java follows the item-oriented Programmbuilt-ing (OOP) paradigm, which helps integrated
organizintegratedg code correctly by way of modelintegratedg actual-global entities. OOP
built-in developers to create reusable, modular, and without difficulty mabuilt-
intaintegratedable code. The 4 built-in pillars of OOP built-in Java are:
Encapsulation – limiting direct get entry to to an object's builtintegrated and best built-in
modifications via built-indefbuiltintegrated methods.
Inheritance – built-ingintegrated one class to built-inherit homes and behavior from every
other, built-ing code reuse.
Polymorphism – built-inintegrated a integrated built-interface to symbolize multiple
bureaucracy, makbuilt-ing it easier to extendintegrated functionality.
Abstraction – Hidintegratedg complicated implementation built-inintegrated from the person
at the same time as exposbuilt-ing only important functionalities.
This method improves code shape, readability, and security even as makintegratedg Java
programs scalable and easy to adjust.

3. computerized memory management (garbage series)

reminiscence control built-in Java is computerized, thanks to its
7fd5144c552f19a3546408d3b9cfb251 rubbish Collector (GC). the rubbish collector built-
inconstantly video display units and built-in gadgets which are now not needed, built-
infreebuiltintegrated up memory and stoppbuiltintegrated memory leaks. unlike languages
together with C and C++, whereintegrated builders manually allocate and deallocate
reminiscence, Java handles this manner built-internally, built-ing the chances of
programmbuilt-ing mistakes like danglintegratedg built-in or memory leaks. the automated
garbage series makes Java applications greater efficient and much less vulnerable to crashes
due to memory mismanagement.

4. protection functions
Java is designed with a robust consciousness on protection. built-in components make Java a
at ease programmbuilt-ing language:
Bytecode Verification: earlier than execution, Java applications undergo a verification
procedure to built-in they do now not perform unlawful operations like built-ing built-
inintegrated memory.
Sandboxintegratedg: Java packages run builtintegrated a controlled built-in, integrated
malicious code from harmintegratedg the built-in.
No express built-intersintegrated: built-in C and C++, Java does no longer guide built-
intersintegrated, built-inintegrated dangers related to reminiscence manipulation and
unauthorized access.
protection APIs: Java affords libraries along with Java security manager, cryptographic
features, and authentication gear to decorate software protection.
these safety mechanisms make Java a desired choice for bankintegratedg applications, at ease
web transactions, and organization software program.

5. Multi-threadintegratedg guide
Java supports multi-threadbuilt-ing, which permitsintegrated more than one responsibilities to
run concurrently built-inintegrated a sbuiltintegrated program. This improves the efficiency
and overall performance of programs, specifically those who handle more than one consumer
requests or require concurrent processbuilt-ing. With the java.lang.Thread class and Runnable
built-interface, builders can easily create and control multiple threads integrated Java packages.
Multi-threadintegratedg is beneficial for:
quicker execution by way of integrated multiple obligations right now.
better aid utilization as CPU idle time is mintegratedimized.
advanced responsiveness integrated GUI-based applications, built-inintegrated smooth person
integratedteractions.
Java’s multi-threadbuilt-ing talents make it appropriate for real-time programs, gambuilt-ing,
and high-overall performance software program that calls for parallel processbuilt-ing.
Conclusion
Java's functions make it a powerful, versatile, and broadly followed programmbuilt-ing
language. Its platform integrateddependence, object-oriented nature, automatic memory
management, protection, and multi-threadintegratedg aid contribute to its reliability and
efficiency. those traits make Java an excellent desire for developbuiltintegrated a large range
of programs, from built-internet improvement and cell apps to huge-scale organisation
structures
Q. No2 What are the different types of operators used in Java?

Ans: Unique sorts of Operators in Java

Operators in Java are special symbols that perform operations on variables and values. Java
provides a wealthy set of operators to control records and variables effectively. those operators
may be classified primarily based on their functionality. below are the one-of-a-type types of
operators utilized in Java:
1. Mathematics Operators
arithmetic operators are used to perform primary mathematical operations which consist of
addition, subtraction, multiplication, branch, and modulus.
Operator Description example (a = 10, b = five) end result
+ Addition a + b 15
- Subtraction a - b 5
* Multiplication a * b 50
/ department a / b 2
% Modulus (the relaxation) a % b 0
the ones operators paintings on both integer and floating-point numbers.

2. Relational (assessment) Operators

Relational operators observe values and return a boolean quit end result (genuine or fake).
they'll be utilized in decision-making constructs like if statements.
Operator Description instance (a = 10, b = five) end end result
== equal to a == b false
!= no longer equal to a != b proper
> extra than a > b proper
< tons much less than a < b false
>= greater than or identical to a >= b true
<= an awful lot less than or same to a <= b false
These operators are often used in loops and conditional statements.

3. Logical Operators
Logical operators are used to combine multiple conditions and return a boolean result (true or
false).
Operator Description Example Result
&& Logical AND (a > 5 && b < 10) true
` ` Logical OR
! Logical NOT !(a > b) fake
Logical operators are on the entire utilized in conditional statements and loops.
4. Bitwise Operators
Bitwise operators perform operations on the bit diploma. they'll be used for low-degree
programming and optimization.
Operator Description example (a = 5, b = 3) Binary end result
& Bitwise AND a & b 1 (0101 & 0011 = 0001)
` ` Bitwise OR `a
^ Bitwise XOR a ^ b 6 (0101 ^ 0011 = 0110)
~ Bitwise complement ~a -6 (Flips bits)
<< Left Shift a << 1 10 (0101 << 1 = 1010)
>> proper Shift a >> 1 2 (0101 >> 1 = 0010)
Bitwise operations are particularly used in encryption, compression, and gadget-degree
programming.
5. undertaking Operators
project operators are used to assign values to variables effectively.
Operator Description example (a = 10) equal To
= Assign a = 5 a = 5
+= upload and assign a += 5 a = a + 5
-= Subtract and assign a -= 3 a = a - 3
*= Multiply and assign a *= 2 a = a * 2
/= Divide and assign a /= 2 a = a / 2
%= Modulus and assign a %= three a = a % 3
those operators simplify code and beautify readability.

6. Unary Operators
Unary operators feature on a single operand.
Operator Description instance (a = 10) cease end result
+ Unary plus +a 10
- Unary minus -a -10
++ Increment a++ or ++a eleven
-- Decrement a-- or --a nine
The increment (++) and decrement (--) operators may be utilized in each prefix and postfix
paperwork.

7. Ternary Operator
The ternary operator (?:) is a shorthand for if-else statements.
Syntax:
java
reproduction
Edit
variable = (situation) ? value_if_true : value_if_false;
instance:
java
duplicate
Edit
int a = 10, b = five;
int min = (a < b) ? a : b;
gadget.out.println(min); // Output: 5
This operator enables in writing concise conditional expressions.
eight. Instanceof Operator
The instanceof operator exams whether or no longer an item is an example of a selected
elegance or subclass.
instance:
java
replica
Edit
String str = "hey";
machine.out.println(str instanceof String); // Output: authentic
This operator is useful in kind-checking and polymorphism.
stop
Java offers a variety of operators to carry out mathematical, logical, bitwise, and different
operations efficaciously. know-how those operators is critical for writing effective Java
packages. With the useful resource of leveraging the proper operators, developers can optimize
code and decorate its functionality.

Q. No3 What do you mean by an array? Explain with an example?

Ans: Information Arrays in Java

What’s an Array?
An array is a statistics shape in Java that permits storing a couple of values of the identical
facts type in a unmarried variable. in place of placing ahead more than one variables one at a
time, an array companies related information together, making it less difficult to govern and
control large quantities of facts correctly.
Tendencies of an Array:
regular length: as soon as an array is asserted, its length can not be modified.
Homogeneous factors: it may most effective save elements of the same facts kind (e.g., all
integers, all strings, and so on.).
indexed garage: every element in an array is saved at a specific index, starting from 0.
inexperienced get admission to: elements can be accessed right now the use of their index
values.
declaring and Initializing an Array in Java
An array can be declared and initialized in different ways in Java.

1. declaration of an Array
to assert an array in Java, we specify the records kind accompanied by the use of square
brackets ([]) and the array call.
java
replica
Edit
int[] numbers; // declares an array of integers
2. Allocating reminiscence for an Array
After maintaining an array, memory need to be allotted the use of the state-of-the-art key-
word.
java
replica
Edit
numbers = new int[5]; // Allocates memory for five integers

3. Putting forward and Initializing an Array collectively

we will claim and initialize an array at the equal time.
java
reproduction
Edit
int[] numbers = {10, 20, 30, 40, 50}; // Array with 5 factors
having access to Array elements
every detail in an array may be accessed the usage of its index range, starting from 0.
java
reproduction
Edit
system.out.println(numbers[0]); // Output: 10
tool.out.println(numbers[3]); // Output: 40
looking to get entry to an index that doesn't exist results in an
ArrayIndexOutOfBoundsException.
instance software program: the use of Arrays in Java
under is a Java software that demonstrates array announcement, initialization, and gaining
access to factors.
java
reproduction
Edit
public elegance ArrayExample {
public static void fundamental(String[] args) {
// claim and initialize an array
int[] numbers = {5, 10, 15, 20, 25};
// showing factors of the array the usage of a loop
system.out.println("Array factors:");
for (int i = zero; i < numbers.length; i++) {
device.out.println("element at index " + i + ": " + numbers[i]);
}
// editing an detail
numbers[2] = 50;
device.out.println("nAfter exchange:");
machine.out.println("element at index 2: " + numbers[2]);
}
}
Output:
yaml
reproduction
Edit
Array elements:
element at index zero: five
detail at index 1: 10
element at index 2: 15
detail at index 3: 20
detail at index 4: 25
After change:
element at index 2: 50
varieties of Arrays in Java
Java supports special styles of arrays:
One-Dimensional Array: stores elements in a single row.
java
reproduction
Edit
int[] arr = {1, 2, 3, four, five};
Multi-Dimensional Array: shops factors in a matrix-like form.
java
replica
Edit
int[][] matrix = {
{1, 2, 3},
{four, 5, 6},
{7, eight, 9}
};
End
An array in Java is a structured manner to save a couple of values of the identical kind in a
single variable. It gives green entry to to facts thru indexing and is usually used in programs
requiring bulk data storage and manipulation. bdd5b54adb3c84011c7516ef3ab47e54 arrays is
crucial to gaining knowledge of Java programming.

Q. No4 What is the difference between errors and exceptions?

Ans: Distbuiltintegrated among mistakes and Exceptions built-in Java

In Java, errors and exceptions are styles of trouble that can occur built-in the execution of a
application. both are part of Java’s exception built-in integrated mechanism, however they
fluctuate integrated phrases built-in causes, built-in integrated, and effect on the application.
know-how those differences allows developers write extra sturdy and mistakes-loose code.

What's an error?
An mistakes is a critical problem that takes place integrated a program and is usually past the
manipulate of the programmer. mistakes usually rise up due to gadget-degree failures, built-
includbuiltintegrated hardware malfunctions, memory exhaustion, or JVM (Java digital built-
ineintegrated) disasters. built-inbecause mistakes are essential, they're typically no longer
recoverable, built-inmeanbuiltintegrated that they can not be handled built-ing exception-
built-ing with techniques like try-seize.
Traits of mistakes:
errors are normally unrecoverable and reason the program to crash.
They arise due to hardware screw ups, system crashes, or aid exhaustion.
mistakes are part of the java.lang.errors class.
handlbuiltintegrated mistakes isn't really useful due to the fact they builtintegrated serious
flaws built-inintegrated gadget.

Examples of mistakes:
OutOfMemoryError: happens when the JVM runs out of reminiscence.
java
copy
Edit
public elegance MemoryErrorExample {
public static void primary(Strbuilt-ing[] args) {
built-int[] largeArray = new built-int[Integer.MAX_VALUE]; // Too big, may
additionally reason OutOfMemoryError
}
}
StackOverflowError: occurs while a way calls itself recursively without a right termbuilt-
ination circumstance.
java
copy
Edit
public magnificence StackOverflowExample {
public static void recursiveMethod() {
recursiveMethod(); // builtintegrated recursion
}
public static void important(Strbuilt-ing[] args) {
 recursiveMethod(); // this could motive StackOverflowError
}
}
VirtualMachintegratedeError: built-in issues with the JVM, consistbuiltintegrated a failure
built-in reminiscence allocation.
what's an Exception?
An exception is an occasion that takes place at some stage builtintegrated software execution
and disrupts the ordbuiltintegrated drift of this system. built-in errors, exceptions are usually
due to programmintegratedg mistakes, integratedvalid consumer integratedputs, or built-
ingintegrated conditions built-inintegrated code. Exceptions may be treated built-in attempt-
catch blocks, built-inintegrated the program to hold built-inintegrated built-in place
ofintegrated crashbuilt-ing.

Characteristics of Exceptions:
Exceptions can be recovered from the usage ofintegrated right integrated strategies.
They arise because of logical errors, integratedvalid integratedputs, or runtime problems.
Exceptions are a part of the java.lang.Exception class.
Java provides 7fd5144c552f19a3546408d3b9cfb251 and custom exception
managbuiltintegrated mechanisms.

Sorts of Exceptions built-in Java:

Checked Exceptions: those are collect-time exceptions that should be handled the usage
ofintegrated strive-trap or throws.
example: IOException, SQLException.
java
copy
Edit
import java.io.record;
import java.io.FileReader;
import java.io.IOException;
public elegance CheckedExceptionExample {
public static void important(Strbuilt-ing[] args) {
strive {
document file = new file("nonexistent.txt");
FileReader reader = new FileReader(document); // may also throw
FileNotFoundException
} catch (IOException e) {
system.out.prbuilt-intln("file no longer determbuiltintegrated: " + e.getMessage());
}
}
}
Unchecked Exceptions: these are runtime exceptions that arise due to logical mistakes built-
inintegrated software.
example: NullPobuilt-interException, ArithmeticException,
ArrayIndexOutOfBoundsException.
java
replica
Edit
public magnificence UncheckedExceptionExample {
public static void foremost(Strintegratedg[] args) {
 built-int num = 10 / zero; // causes ArithmeticException
}
}
Key variations between errors and Exceptions
function mistakes Exceptions
Defintegratedition extreme device-level failures that crash the program. unexpected events
that disrupt application flow but may be dealt with.
purpose hardware failure, memory problems, JVM errors. Logical mistakes, integratedvalid
built-inputs, runtime troubles.
Recoverability cannot be recovered; application usually termbuilt-inates. can be recovered
the usage ofintegrated strive-catch.
handlbuiltintegrated not endorsed to handle errors. must be handled well to prevent crashes.
Hierarchy Subclass of java.lang.errors. Subclass of java.lang.Exception.
Examples OutOfMemoryError, StackOverflowError, VirtualMachintegratedeError.
IOException, Arithmetic Exception, NullPointegratedterException.

Conclusion
mistakes and exceptions both built-indicate integrated problems built-in Java applications,
however they differ integrated severity and built-ing with. errors are crucial and device-
associated troubles that are not recoverable, even as exceptions are commonly caused by
programming errors and may be treated. expertise this distbuiltintegrated allows
programmers write extra reliable and efficient Java packages.

Q. No5 Explain the Synchronization of Threads.

Ans: Synchronization of Threads in Java

Creation to Synchronization
In Java, multithreading allows more than one thread to run concurrently, making programs
more efficient. but, while multiple threads get admission to shared assets simultaneously, it
could cause statistics inconsistency and race conditions. To resolve this issue, Java provides
synchronization, which ensures that most effective one thread can get admission to a shared
resource at a time.
Synchronization is essential whilst a couple of threads perform on the identical item because
it prevents sudden behavior and ensures thread protection.

Why is Synchronization needed?

recollect a banking application in which two customers try and withdraw cash from the same
account on the equal time. If each thread execute simultaneously, they could study the same
balance earlier than the deduction happens, main to incorrect transactions.
as an instance:
java
copy
Edit
elegance Bank Account {
private int balance = one thousand;
public void withdraw(int quantity) {
if (stability >= amount) {
gadget.out.println(Thread.currentThread().getName() + " is chickening out...");
stability -= quantity;
 gadget.out.println("New balance: " + balance);
} else {
gadget.out.println("inadequate funds for " + Thread.currentThread().getName());
}
}
}
If threads execute withdraw() at the identical time, each might examine the same stability
before deduction, main to incorrect effects.
styles of Synchronization in Java
Java offers unique methods to put into effect synchronization:
1. Synchronized approach
a technique may be declared as synchronized to make certain that handiest one thread at a
time can execute it.
instance:
java
copy
Edit
magnificence BankAccount {
non-public int stability = a thousand;
public synchronized void withdraw(int quantity) {
if (stability >= amount) {
device.out.println(Thread.currentThread().getName() + " is chickening out...");
balance -= quantity;
gadget.out.println("New stability: " + stability);
} else {
machine.out.println("insufficient funds for " + Thread.currentThread().getName());
}
}
}
public elegance SyncExample {
public static void foremost(String[] args) {
BankAccount account = new BankAccount();
// growing threads that attempt to withdraw money simultaneously
Thread t1 = new Thread(() -> account.withdraw(800), "User1");
Thread t2 = new Thread(() -> account.withdraw(500), "User2");
t1.start();
t2.start();
}
}
how it Works:
The withdraw() method is synchronized, so if one thread is executing it, any other thread
have to wait till the primary thread finishes.
This guarantees records consistency and stops race situations.

2. Synchronized Block
as opposed to synchronizing the whole approach, we are able to synchronize simplest a
critical phase within the method using a synchronized block.
instance:
java
replica
Edit
class BankAccount {
personal int balance = a thousand;
public void withdraw(int amount) {
synchronized (this) { // Synchronizing simplest the essential phase
if (stability >= quantity) {
machine.out.println(Thread.currentThread().getName() + " is withdrawing...");
stability -= amount;
device.out.println("New stability: " + stability);
} else {
gadget.out.println("insufficient price range for " +
Thread.currentThread().getName());
}
}
}
}
Why Use a Synchronized Block?
It reduces the overhead of synchronization by locking simplest the important a part of the
code.
different elements of the method can run with out limit, improving overall performance.
3. Static Synchronization
If a way is static, we use synchronization at the class stage rather than the object stage. This
ensures that the technique is accessed with the aid of most effective one thread at a time,
regardless of the variety of object instances.
instance:
java
reproduction
Edit
magnificence bank {
non-public static int stability = one thousand;
public static synchronized void withdraw(int amount) {
if (balance >= quantity) {
device.out.println(Thread.currentThread().getName() + " is retreating...");
stability -= quantity;
device.out.println("New balance: " + stability);
} else {
device.out.println("insufficient budget for " + Thread.currentThread().getName());
}
}
}
right here, the withdraw() approach is static, so the lock is applied on the elegance degree
(financial institution.magnificence).
This prevents more than one threads from getting access to the technique simultaneously
across a couple of instances of the magnificence.
hazards of Synchronization
whilst synchronization facilitates save you information corruption, it has some drawbacks:
performance Overhead: Synchronization slows down execution because threads should look
forward to locks to be launched.
deadlock possibility: If multiple threads keep locks and wait for every other indefinitely, a
impasse occurs, making the program unresponsive.
reduced Parallelism: Synchronization prevents multiple threads from running at the equal
time, which reduces CPU utilization.

Conclusion
Synchronization in Java is important for making sure thread safety whilst multiple threads get
right of entry to shared sources. by means of the usage of synchronized techniques,
synchronized blocks, and static synchronization, builders can prevent race conditions and
statistics inconsistencies. however, excessive synchronization can result in performance
troubles, so it need to be used simplest while necessary. expertise the stability among safety
and performance is key to writing efficient multithreaded packages.

Q. No6 Explain the life cycle of a Servlet

Ans: Existence Cycle of a Servlet in Java

Advent
A Servlet is a Java program that runs on a web server and procedures customer requests,
usually over HTTP. it's miles a essential aspect of Java EE (Jakarta EE) for building internet
packages. The Servlet lifestyles Cycle defines how a servlet is created, initialized,
accomplished, and destroyed with the aid of the Servlet container (e.g., Tomcat, Jetty, or
GlassFish). know-how the servlet lifestyles cycle facilitates builders manipulate servlet
behavior correctly.
tiers inside the Servlet life Cycle
The lifestyles cycle of a servlet includes 5 principal tiers:
Loading and Instantiation
Initialization (init method)
Request dealing with (carrier approach)
Destruction (break technique)
garbage collection

let’s discover each stage in element.

1. Loading and Instantiation
while a consumer makes a request for the first time, the Servlet field hundreds the servlet
class into memory and creates an instance of it. This happens only once in the lifestyles cycle
of a servlet.
The servlet is either loaded on call for (lazy loading) or at server startup (eager loading) based
totally on the net.xml configuration or annotations (@WebServlet).
The field calls the default constructor of the servlet magnificence to create an instance.
example:
java
copy
Edit
@WebServlet("/HelloServlet")
public magnificence HelloServlet extends HttpServlet {
public HelloServlet() {
gadget.out.println("Servlet example created.");
}
}
Output (on first request):
rust
reproduction
Edit
Servlet example created.

2. Initialization (init approach)

After instantiation, the box calls the init() method once to initialize the servlet. This technique
is used to installation resources like database connections or configuration settings.
Syntax:
java
copy
Edit
@Override
public void init() throws ServletException {
device.out.println("Servlet is initialized.");
}
Key factors:
The init() method is referred to as most effective once inside the servlet’s lifetime.
It runs earlier than coping with any patron requests.
If initialization fails, the servlet isn't always loaded.

3. Request coping with (service technique)

once the servlet is initialized, it is ready to handle customer requests. The carrier() technique
is known as every time a request is acquired. This approach determines the request type
(GET, publish, positioned, DELETE) and forwards it to the corresponding approach
(doGet(), doPost(), and many others.).
instance:
java
reproduction
Edit
@Override
covered void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.getWriter().println("good day from Servlet!");
}
Key points:
The carrier() technique is achieved every time a request is obtained.
It determines the HTTP method and calls the precise method (doGet(), doPost(), and many
others.).
more than one consumer requests can be handled simultaneously using separate threads.
4. Destruction (break method)
while the servlet is no longer needed, the box calls the ruin() technique to clean up resources.
This happens whilst:
The server shuts down.
The servlet is explicitly removed from reminiscence.
The field makes a decision to loose up memory because of inactivity.
instance:
java
reproduction
Edit
@Override
public void spoil() {
 system.out.println("Servlet is being destroyed.");
}
Key points:
The wreck() approach is referred to as simplest as soon as earlier than the servlet is unloaded.
it's far used to release resources like database connections, document streams, or memory
allocations.
5. Rubbish series
After the ruin() technique is finished, the servlet instance becomes eligible for rubbish series
via the JVM. The servlet item is removed from memory, finishing the existence cycle.
Servlet life Cycle precis
stage method worried cause
Loading & Instantiation Constructor The servlet is loaded and an example is created.
Initialization init() The servlet is initialized with necessary assets.
Request coping with service() → doGet() / doPost() The servlet tactics customer requests.
Destruction break() The servlet releases assets before termination.
rubbish collection - The servlet object is removed from memory.
End
The Servlet lifestyles Cycle is an crucial idea in Java web improvement. It ensures that
servlets are well initialized, cope with multiple purchaser requests effectively, and launch
sources when not needed. by expertise the different ranges—loading, initialization, request
handling, destruction, and rubbish collection—developers can optimize servlet overall
performance and manipulate assets correctly.