Q1.Explain TreeMap and HashMap classes of collection framework.

The Collection in Java is a framework that provides an architecture to store and

manipulate the group of objects.
The Collection Framework in Java is a group of classes and interfaces that make it
easier to store and manage groups of objects. It provides various ways to handle
data, such as lists, sets, and maps. This framework helps programmers work with
collections of objects without worrying about the underlying details, making it
simpler to perform tasks like adding, removing, or searching for items.
Java Collections can achieve all the operations that you perform on a data such as
searching, sorting, insertion, manipulation, and deletion.
A Map is a collection that stores data in key-value pairs. Each key is unique, and
you can use it to quickly find the corresponding value. For instance, in a phone
book, the name (key) maps to a phone number (value). Overall, the Collection
Framework provides powerful tools to help you manage data effectively in Java,
making your programming tasks easier and more efficient.
Map Interface:
A Map is an object that maps keys to values, with each key being unique. It is
not a true subtype of the Collection interface but is part of the Java Collections
Framework. Maps are ideal for associative arrays where you want to retrieve a
value based on a key. Common implementations include HashMap,
LinkedHashMap, and TreeMap.

TreeMap and HashMap in Java Collection Framework

Both TreeMap and HashMap are part of the Java Collection Framework and are
used to store key-value pairs, but they work differently. Let’s break them down:

1. HashMap:

 Data Structure: Uses a hash table to store the key-value pairs.

 Ordering: It does not maintain any order of the elements. The order of
insertion is not preserved.
 Performance: Very fast for basic operations like adding, removing, or
finding an element, with an average time complexity of O(1).
 Null Values: It allows one null key and multiple null values.
 Use Case: When you need fast performance and don’t care about the order
of the elements.

Syntax:
HashMap<K, V> map = new HashMap<>();
import java.util.HashMap;

public class Main {

public static void main(String[] args) {
// Creating a HashMap
HashMap<Integer, String> map = new HashMap<>();

// Adding elements
map.put(1, "Apple");
map.put(2, "Banana");
map.put(3, "Cherry");

// Displaying the HashMap

System.out.println("HashMap: " + map);
}
}

//output HashMap: {1=Apple, 2=Banana, 3=Cherry}

2. TreeMap:

 Data Structure: Uses a Red-Black tree (a self-balancing binary search

tree).
 Ordering: It maintains the natural order of the keys (ascending order by
default). If a custom comparator is provided, it will order according to that.
 Performance: Slightly slower than HashMap for basic operations, with an
average time complexity of O(log n) due to the tree structure.
 Null Values: It does not allow null keys, but it allows multiple null values.
 Use Case: When you need to maintain a sorted order of keys.

Syntax
TreeMap<K, V> map = new TreeMap<>();

Example:

import java.util.TreeMap;

public class Main {

public static void main(String[] args) {

// Creating a TreeMap
 TreeMap<Integer, String> map = new TreeMap<>();

// Adding elements

map.put(3, "Cherry");

map.put(1, "Apple");

map.put(2, "Banana");

// Displaying the TreeMap

System.out.println("TreeMap: " + map);

//output TreeMap: {1=Apple, 2=Banana, 3=Cherry}

Key Differences:

1. Ordering:
o HashMap: No order.
o TreeMap: Sorted order (ascending or custom).
2. Performance:
o HashMap: Faster for operations like insert, delete, and lookup.
o TreeMap: Slower because of maintaining order.
3. Null Keys:
o HashMap: Allows one null key.
o TreeMap: Does not allow null keys.

By understanding these differences, you can choose which class to use depending
on whether you need a sorted map or just a fast one.

Q2. Compare the TreeMap and HashMap classes of collection framework

Comparison of TreeMap and HashMap in Java Collection Framework

TreeMap and HashMap are both part of the Java Collection Framework and store
data in key-value pairs. However, they work in different ways and have unique
features. Below is a detailed comparison based on various aspects.
1. Underlying Data Structure:

 HashMap: It uses a hash table to store key-value pairs. This means it

applies a hash function on the keys and stores them in buckets based on their
hash code.
 TreeMap: It uses a Red-Black tree (a type of self-balancing binary search
tree). The keys are stored in a sorted, ordered structure.

2. Order of Elements:

 HashMap: It does not maintain any specific order for its elements. The
insertion order of elements is not preserved, and the order in which elements
are stored can change.
 TreeMap: It maintains a sorted order of the keys. By default, it sorts keys
in their natural order (ascending). You can also provide a custom
comparator to define a different sorting order.

3. Performance:

 HashMap: Offers better performance for basic operations like put(), get(),
and remove() due to its hash table structure. The time complexity for these
operations is generally O(1) (constant time) on average.
 TreeMap: Because it uses a tree structure, the time complexity for
operations like put(), get(), and remove() is O(log n). This is slower than
HashMap, especially for large datasets.

4. Null Handling:

 HashMap: Allows one null key and multiple null values.

 TreeMap: Does not allow null keys but can store multiple null values.

5. Usage:

 HashMap: Use HashMap when you need fast performance and do not care
about the order of elements. It is ideal when you just want to store and
retrieve data quickly.
 TreeMap: Use TreeMap when you need the keys to be sorted in a specific
order. This is useful when you need to perform operations like range
searches or need data to be sorted.

6. Synchronization:

 Neither HashMap nor TreeMap is synchronized by default, which means

they are not thread-safe. You can make them thread-safe using
Collections.synchronizedMap().
7. Internal Working:

 HashMap: Calculates the hash code of the keys and distributes them across
different buckets to avoid collisions.
 TreeMap: Uses the comparison of keys to maintain a balanced tree
structure. Elements are stored in the tree based on comparisons, and it
automatically balances itself to ensure performance.

8. Use Cases:

 HashMap: Suitable when fast lookup and insertion are required, and
ordering is not a priority. Examples include caching, storing session data, or
managing large datasets.
 TreeMap: Ideal when sorted key order is important. Examples include
applications where you need to perform sorted operations on data, such as in
priority queues or for range queries.

Key Differences at a Glance:

Feature HashMap TreeMap

Underlying Structure Hash table Red-Black Tree
Order of Elements No order Sorted (ascending or custom)
Time Complexity O(1) for basic operations O(log n) for basic operations
Null Keys Allows one null key Does not allow null keys
Performance Faster for large datasets Slower due to sorting
Use Case When speed is important When sorted data is required

Conclusion:

In summary, HashMap is best for fast access to data without caring about the
order, while TreeMap is useful when the order of keys matters. Choose HashMap
for performance and TreeMap when sorting or ordered traversal of keys is
required.

This detailed comparison shows how both classes are similar in purpose (storing
key-value pairs) but differ significantly in how they handle data and performance,
helping you choose the right one based on your specific needs.
Q3.What are Java Generics to design and explain how generics could help
prevent runtime errors.

1. What Are Java Generics?

Java Generics allow you to define a generic type or parameter, which can be
replaced with a specific type when the code is used. It’s like creating a blueprint
that works with any type, and then later you decide what type to use.

For example, you can create a generic class that can handle integers, strings, or
any other data type without rewriting the code.

Syntax for Generics:

class ClassName<T> {
// Code using T as a placeholder for the type
}

In the above code:

 T is a placeholder for a type, also called a type parameter.

 When you use the class, you can replace T with a specific type, like Integer,
String, etc.

2. How Generics Prevent Runtime Errors

In Java, before Generics were introduced, collections like ArrayList or HashMap

could store any object, which could lead to type-casting errors at runtime. For
example, you could mistakenly add a String into a list of Integers, and the error
would only be caught when you try to retrieve the element and cast it back to an
Integer.

Generics solve this by allowing you to specify the type of objects the collection
can hold at compile time, so you can't add the wrong type of object. If you try to,
the compiler will throw an error immediately, preventing the potential runtime
error.

3. Benefits of Java Generics

1. Type Safety: Generics allow you to specify the exact data type being used.
This ensures that the compiler checks for type compatibility during
compilation, reducing the chances of a ClassCastException.
 2. Elimination of Casting: Without generics, you need to manually cast
objects when retrieving them from a collection. With generics, the casting is
handled automatically.
3. Code Reusability: Generics make your code more flexible and reusable.
You can use the same class or method for different types without rewriting
the code for each type.

4. Example Without Generics (Prone to Runtime Errors)

Here’s an example without generics, which can cause problems:

import java.util.ArrayList;

public class Main {

public static void main(String[] args) {
// Creating a list without Generics
ArrayList list = new ArrayList();

// Adding elements of different types

list.add("Hello");
list.add(123); // Adding an integer to a list of strings

// Trying to retrieve the elements

String str = (String) list.get(1); // This will cause a ClassCastException
System.out.println(str);
}
}

 Problem: The code will throw a ClassCastException at runtime because an

integer (123) was added to the list, but we are trying to cast it to a string.

5. Example With Generics (Type Safe and No Runtime Errors)

Now, using generics prevents such issues at compile time:

Example:

// Generic Box class

class Box<T> {
private T item;

// Method to set the item

public void setItem(T item) {
this.item = item;
}
 // Method to get the item
public T getItem() {
return item;
}
}

// Main class
public class Main {
public static void main(String[] args) {
// Creating a Box for Integer
Box<Integer> integerBox = new Box<>();
integerBox.setItem(123);
System.out.println("Integer Value: " + integerBox.getItem());

// Creating a Box for String

Box<String> stringBox = new Box<>();
stringBox.setItem("Hello Generics");
System.out.println("String Value: " + stringBox.getItem());
}
}

//output
// Integer Value: 123
//String Value: Hello Generics

In this example:

 The same class Box<T> is used to handle Integer, String, and Double
objects without changing the class definition.
 By specifying the type (Integer, String, Double), we ensure that the
setItem() and getItem() methods can only accept and return the correct
types.
 If you tried to add a different type, such as a String in the Box<Integer>, the
compiler would give an error, preventing a potential runtime exception.

Conclusion:

Java Generics play a crucial role in preventing runtime errors by ensuring type
safety at compile time. They remove the need for manual type casting and provide
a flexible way to write reusable and reliable code. By enforcing that only the
correct types are used, they help to avoid common bugs and exceptions, making
the code more robust and easier to maintain.
In summary:

 Generics ensure type safety by preventing incorrect data types from being
used.
 Generics improve code reusability by allowing methods and classes to
operate on various data types without rewriting the code.
 Generics reduce runtime errors by catching type mismatches at compile
time.

This approach greatly enhances the reliability of code and is essential for working
with collections and other complex structures in Java.

Q4. Analyze how you could use Java Generics to design a flexible and type-
safe solution for handling different and explain how generics could help
prevent runtime errors.

How Java Generics Provide Flexibility and Type Safety

Using Java Generics, you can create classes, methods, and interfaces that can
work with any data type. By specifying the data type when you create an instance,
you ensure that only objects of that specific type are allowed, thus preventing type-
related runtime errors.

Here's how Generics help:

1. Flexible Design: Generics let you define code that works with multiple
types, making your design more flexible and reusable. For example, a
generic Box<T> class can store any object (T being the placeholder for a
specific type like Integer, String, or custom objects).
2. Type-Safety at Compile Time: Without generics, you might need to
perform typecasting, which can lead to runtime errors if you mistakenly cast
an object to the wrong type. Generics eliminate the need for casting and
catch type errors at compile time, making your code safer.

How Generics Prevent Runtime Errors

1. Type-Safe Collections: Collections like ArrayList<T>, HashMap<K, V>,

and Set<T> use generics to ensure that they store and retrieve objects of a
specific type, avoiding accidental type mismatches.
2. Compile-Time Checking: With generics, errors like adding the wrong type
of object (e.g., adding a String to a list of Integers) are detected at compile
time, not runtime. This prevents the common ClassCastException that
could otherwise occur.
 3. No Need for Casting: Without generics, you would need to cast objects
when retrieving them from collections, which is error-prone. With generics,
the need for casting is eliminated, reducing the risk of runtime errors.

Q5. What is Java lambda expressions? What are the advantages of it?
Lmbda Expression Defination:
A lambda expression can be understood as a concise
representation of an anonymous function that can be
passed around: it doesn’t have a name, but it has a list of
parameters, a body, a return type, and also possibly a list of
exceptions that can be thrown.
import java.util.*;

public class Main {

public static void main(String[] args) {
List<String> words = Arrays.asList("apple", "banana", "cherry", "date");

// Sorting words by length using an anonymous inner class

Collections.sort(words, new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
return Integer.compare(s1.length(), s2.length());
}
});

System.out.println(words);
}
}

Advantages of Java Lambda Expressions

1. Concise Code: Lambda expressions reduce the amount of boilerplate code,

making the code shorter and more readable compared to traditional
approaches like anonymous inner classes.
2. Improved Readability: By removing unnecessary syntax, lambda
expressions make code easier to understand at a glance, especially in cases
like event handling or iteration.
 3. Functional Programming Support: Lambda expressions bring functional
programming concepts to Java, allowing developers to treat functions as
first-class citizens. This makes Java more flexible and expressive.
4. Simplified Functional Interface Implementation: Lambda expressions
can easily implement functional interfaces (interfaces with only one abstract
method) in a more direct and cleaner way.
5. Efficient Iteration of Collections: When used with the Stream API, lambda
expressions allow developers to filter, map, and process collections more
efficiently and clearly.
6. Enables Parallel Processing: Lambda expressions, combined with the
Stream API, simplify parallel operations on collections, improving
performance in multi-threaded environments.
7. No Need for Explicit Type Declarations: The Java compiler can infer
types in many cases, reducing the amount of redundant type declarations in
the code.

Q6 Analyze how Java lambda expressions can improve the readability and
efficiency of your code. Discuss how lambdas compare to traditional
approaches using anonymous inner classes in terms of performance, syntax,
and maintenance.

How Java Lambda Expressions Improve Readability and Efficiency

Java lambda expressions were introduced in Java 8 to make code more concise,
readable, and efficient. They allow you to write functions in a cleaner and more
direct way compared to traditional approaches like anonymous inner classes.
Lambdas simplify the syntax, reduce boilerplate code, and improve both
readability and performance in specific scenarios.

1. Improving Readability with Lambda Expressions

Before lambda expressions, developers had to use anonymous inner classes to

implement functional interfaces (interfaces with a single abstract method). This
made the code more verbose and harder to read.

Example Without Lambda (Anonymous Inner Class):

Runnable runnable = new Runnable() {

@Override

public void run() {

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

}
};

Example With Lambda Expression:

Runnable runnable = () -> System.out.println("Running...");

 Anonymous Inner Class: Requires multiple lines of code just to implement

a simple run() method.
 Lambda Expression: Reduces the code to a single line, improving
readability by directly showing the functionality.

With lambda expressions, you don’t need to define the method name (run()), return
type, or even the parameter type. The compiler infers this information, making the
code shorter and easier to understand.

3. Performance Comparison: Lambda vs Anonymous Inner Class

Lambda expressions can potentially offer better performance than anonymous

inner classes because:

1. Reduced Memory Overhead: Anonymous inner classes often result in

additional memory overhead because a new class file is created for each
instance. Lambda expressions, on the other hand, are implemented more
efficiently using the invokedynamic bytecode instruction, which makes
them lightweight.
2. Optimized Execution: Lambda expressions are designed to be optimized by
the JVM. This means that they can be more efficient at runtime compared
to traditional anonymous inner classes.
3. Lazy Execution with Streams: When used with the Stream API, lambda
expressions allow for lazy evaluation, meaning that operations on streams
are only performed when needed. This can lead to performance gains in
large data sets by avoiding unnecessary operations.

However, the actual performance difference between lambdas and anonymous

inner classes may not be noticeable in small, simple cases. For larger applications
or scenarios where parallel processing is needed, lambdas can show significant
performance benefits.

4. Syntax Comparison: Lambda vs Anonymous Inner Class

The syntax of lambda expressions is much simpler compared to anonymous inner

classes. Here’s a comparison to highlight the differences:

Anonymous Inner Class (Traditional Approach):

Comparator<String> comparator = new Comparator<String>() {
 @Override

public int compare(String s1, String s2) {

return s1.length() - s2.length();

};

Lambda Expression (Modern Approach):

Comparator<String> comparator = (s1, s2) -> s1.length() - s2.length();

 Anonymous Inner Class: Requires defining the compare() method, which

adds unnecessary verbosity.
 Lambda Expression: Directly expresses the logic of comparing two strings
by their length, reducing the amount of code.

With lambda expressions, you only focus on the essential logic, which makes the
code more concise and easier to maintain.

5. Maintenance: Lambda vs Anonymous Inner Class

Lambda expressions make code easier to maintain for several reasons:

1. Less Boilerplate: Anonymous inner classes require more code (class

definition, method override), which can make maintaining code harder in
large projects. Lambda expressions remove this extra code.
2. Focus on Logic: Lambda expressions allow developers to focus on the core
logic without worrying about method names or types. This leads to fewer
opportunities for errors when maintaining code.
3. Easier Refactoring: Since lambda expressions use functional programming
concepts, refactoring code becomes easier, especially when working with
streams or collections.

For example, if you need to change how an operation is performed on a list, you
can modify a lambda expression more easily than an anonymous inner class, which
might involve changing method names or signatures.

Q7.Demonstrate the request implicit object of JSP with example and how to
handle cases where some fields might be missing or empty in the submission.

JSP request Implicit Object

In JSP (JavaServer Pages), the request implicit object represents the HTTP
request that a client (usually a browser) sends to a web server. It allows you to
access form data, headers, cookies, and attributes sent with the HTTP request. The
request object is an instance of the HttpServletRequest class.

You often use the request object to retrieve form parameters submitted through
HTML forms.

How to Use request Implicit Object in JSP

When a user submits a form, the data can be retrieved using the
request.getParameter("parameterName") method. This method fetches the value of
the form field identified by parameterName. If a field is missing or empty,
getParameter() returns null.

Example Scenario:

Imagine a simple login form where a user submits their username and password.
We'll demonstrate how to use the request object to retrieve the submitted values
and handle cases where some fields might be missing or empty.

1. HTML Form (login.html):

<!DOCTYPE html>

<html>

<head>

<title>Login Form</title>

</head>

<body>

<form action="login.jsp" method="post">

Username: <input type="text" name="username"><br>

Password: <input type="password" name="password"><br>

<input type="submit" value="Login">

</form>

</body>
</html>

2. JSP Page (login.jsp):

<%@ page language="java" contentType="text/html; charset=UTF-8"

pageEncoding="UTF-8"%>

<!DOCTYPE html>

<html>

<head>

<title>Login Result</title>

</head>

<body>

<h2>Login Result</h2>

<%

// Retrieve form parameters using the request object

String username = request.getParameter("username");

String password = request.getParameter("password");

// Handle cases where fields might be missing or empty

if (username == null || username.trim().isEmpty()) {

out.println("<p>Error: Username is missing!</p>");

} else if (password == null || password.trim().isEmpty()) {

out.println("<p>Error: Password is missing!</p>");

} else {

// If both fields are filled, display a success message

out.println("<p>Welcome, " + username + "!</p>");

 }

%>

</body>

</html>

Explanation of login.jsp:

 Retrieving Form Data:

The request.getParameter("username") retrieves the value of the username
field, and request.getParameter("password") retrieves the password.
 Handling Missing or Empty Fields:
o If the username or password fields are missing (not filled in by the
user) or are empty, the code checks using username == null ||
username.trim().isEmpty().
o trim() removes any leading or trailing spaces, and isEmpty() checks if
the string is empty after removing spaces.
 Error Handling:
If the user leaves any field empty or submits a form without entering
anything, an error message will be displayed.

Output:

1. Case 1: Missing Username or Password

If the user submits the form without entering a username or password, the
JSP page will display an appropriate error message:
o Missing Username: "Error: Username is missing!"
o Missing Password: "Error: Password is missing!"
2. Case 2: Both Fields Filled
If the user fills both fields, the JSP page will display a success message:
o Example: "Welcome, John!" (where "John" is the entered username).

Summary of Key Points:

 The request object is used to retrieve form data submitted from an HTML
form.
 The getParameter() method returns the value of a form field or null if the
field is missing or empty.
 It's important to handle cases where form fields might be missing or left
empty to ensure your web application can gracefully handle errors or
incomplete submissions.
By using simple checks like isEmpty() or == null, you can prevent errors and
provide useful feedback to the user, ensuring a better user experience.

Q8. Create a JSP page that uses the request implicit object to retrieve data
submitted by a form with fields for email and username. Use the retrieved
data to display a personalized welcome message on the JSP page with
username and email.

Here’s an easy example of a JSP page that uses the request implicit object to
retrieve data submitted by a form with fields for email and username. The page
will then display a personalized welcome message using the retrieved data.

1. HTML Form (form.html):

This form will collect the username and email from the user.

<!DOCTYPE html>

<html>

<head>

<title>User Information</title>

</head>

<body>

<h2>Enter your details</h2>

<form action="welcome.jsp" method="post">

Username: <input type="text" name="username" required><br>

Email: <input type="email" name="email" required><br>

<input type="submit" value="Submit">

</form>

</body>

</html>

This is a simple HTML form with two fields: username and email. The form
submits the data to welcome.jsp using the POST method.
2. JSP Page (welcome.jsp):

This JSP page retrieves the username and email from the form submission and
displays a personalized welcome message.

<%@ page language="java" contentType="text/html; charset=UTF-8"

pageEncoding="UTF-8"%>

<!DOCTYPE html>

<html>

<head>

<title>Welcome</title>

</head>

<body>

<h2>Welcome to the site!</h2>

<%

// Retrieve the username and email from the request object

String username = request.getParameter("username");

String email = request.getParameter("email");

// Display a personalized message if both fields are provided

if (username != null && !username.trim().isEmpty() && email != null &&

!email.trim().isEmpty()) {

out.println("<p>Welcome, " + username + "!</p>");

out.println("<p>Your email address is: " + email + "</p>");

} else {

out.println("<p>Error: Both username and email are required!</p>");

}
 %>

</body>

</html>

Explanation of welcome.jsp:

 Retrieving Form Data:

o The request.getParameter("username") retrieves the username
entered by the user.
o The request.getParameter("email") retrieves the email entered by the
user.
 Displaying a Personalized Message:
o If both username and email are provided, the page will display a
welcome message that includes both the username and email.
o If either the username or email is missing, an error message will be
displayed.
 Empty Field Check:
o The username != null && !username.trim().isEmpty() and email !=
null && !email.trim().isEmpty() checks ensure that the fields are not
empty or just whitespace.

Welcome, John!

Your email address is: john@example.com

If either field is missing:

Error: Both username and email are required!

Q8. Demostrate the Custom tags with example of formatting date.

Custom tags in JSP are a way to define your own tag library to extend the
functionality of JSP. These tags are typically used to encapsulate reusable logic in
a modular way, making the JSP pages cleaner and easier to manage.

Why Use Custom Tags?

Custom tags improve code reusability and maintainability. By encapsulating

complex logic in reusable tags, developers keep JSP pages focused on presentation.
This separation of concerns makes it easier to update logic without modifying
multiple pages, while also allowing non-Java developers to use custom tags
seamlessly.

Steps to Create a Custom Tag

To create a custom tag:
1. Define the Tag Handler Class: The class extends TagSupport or
BodyTagSupport and implements doStartTag() to specify actions when the
tag is encountered.
2. Create the TLD File: The .tld file links the tag name to its handler class,
making the tag accessible in JSP.
3. Use the Tag in JSP: After defining and linking the tag, it can be used in any
JSP page by importing the tag library with <%@ taglib %> and invoking the
tag.

1. Java Tag Handler Class: DateFormatterTag.java

This Java class implements the tag handler logic. It formats the current date
based on the pattern provided in the JSP page.
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.SimpleTagSupport;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateFormatterTag extends SimpleTagSupport {

private String pattern;

// Setter for the 'pattern' attribute

public void setPattern(String pattern) {
this.pattern = pattern;
}

@Override
public void doTag() throws JspException, IOException {
// Get current date
Date currentDate = new Date();

// Format the date using the pattern

SimpleDateFormat dateFormat = new SimpleDateFormat(pattern);
String formattedDate = dateFormat.format(currentDate);

// Output the formatted date to the JSP

getJspContext().getOut().write(formattedDate);
}
}
 2. Tag Library Descriptor (TLD) File: date-formatter.tld
This XML file defines the custom tag and associates it with the
DateFormatterTag Java class.
Location: WEB-INF/tlds/date-formatter.tld
<?xml version="1.0" encoding="UTF-8"?>
<taglib xmlns="http://java.sun.com/xml/ns/jsp"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/jsp
http://java.sun.com/xml/ns/jsp/web-jsptaglibrary_2_0.xsd"
version="2.0">
<tlib-version>1.0</tlib-version>
<short-name>Date Formatter</short-name>
<uri>/WEB-INF/tlds/date-formatter.tld</uri>

<tag>
<name>formatDate</name>
<tag-class>DateFormatterTag</tag-class>
<body-content>empty</body-content>
<attribute>
<name>pattern</name>
<required>true</required>

</attribute>
</tag>
</taglib>

3. JSP Page: index.jsp

This JSP page will use the custom tag to display the current date in the format
specified by the pattern attribute.

Location: index.jsp

<%@ taglib uri="/WEB-INF/tlds/date-formatter.tld" prefix="custom" %>

<!DOCTYPE html>
<html>
 <head>
<title>Formatted Date</title>
</head>
<body>
<h2>Formatted Date Example</h2>
<p>Current Date (MM-dd-yyyy):</p>
<custom:formatDate pattern="MM-dd-yyyy" />

<p>Current Date (yyyy/MM/dd):</p>

<custom:formatDate pattern="yyyy/MM/dd" />
</body>
</html>
Output

Formatted Date Example

Current Date (MM-dd-yyyy):

11-13-2024

Current Date (yyyy/MM/dd):

2024/11/13

Q9 Imagine you are tasked with repeatedly formatting and displaying dates in
multiple sections of a JSP application. Create a reusable custom JSP tag,
<formatDate>, that will display the date like "2024-11-11 10:15AM".

<%@ taglib uri="/WEB-INF/tlds/date-formatter.tld" prefix="custom" %>

<!DOCTYPE html>

<html>

<head>

<title>Formatted Date</title>

</head>

<body>

<h2>Formatted Date Example</h2>

<p>Current Date and Time (Default Format):</p>

<custom:formatDate />

<p>Current Date and Time (Custom Format: yyyy/MM/dd HH:mm):</p>

<custom:formatDate pattern="yyyy/MM/dd HH:mm" />

</body>

</html>

Q10. What is POJO (Plain Old Java Object) Programming Model. Explain it
with the example.

A POJO (Plain Old Java Object) is a simple Java class that does not depend on
any specific framework, library, or API. It is designed to store and represent data
using private fields with public getter and setter methods. POJOs make Java
programming simpler and more flexible by keeping the code lightweight and free
of unnecessary restrictions. They are commonly used to transfer data between
different layers of an application, ensuring clean and reusable code.

For example, a Student POJO class might have private fields like name, age,
and rollNumber, with public methods to get and set their values. Here's how it
works: a Student object is created, values are assigned using setter methods, and
those values can later be retrieved using getter methods. This approach allows
developers to work with data in a structured, easy-to-understand way, without
depending on any external frameworks.
Key Characteristics of POJOs:

1. No dependency: POJOs are not dependent on any specific framework or

API, making them lightweight and reusable.
2. No predefined restrictions: They do not have to extend specific classes or
implement interfaces.
3. Encapsulation: They are commonly used to represent data with private
fields, getters, setters, and constructors.
4. Flexibility: POJOs can be easily serialized and deserialized, making them
suitable for transferring data between layers..

Advantages of POJOs:

1. Simplicity: POJOs are simple and free from unnecessary complexity. They
just store data.
2. Reusability: POJOs can be used across different frameworks and
applications.
3. Testability: POJOs can be easily tested since they do not rely on any
complex external frameworks or services.
4. Maintainability: The simple structure of POJOs makes the codebase easier
to maintain.

POJO Example:

Let's create a simple POJO for representing a Student entity that stores data like
name, roll number, and age.

1. Student POJO Class:

public class Student {
// Private fields (only two variables)
private String name;
private int age;

// Constructor to initialize the POJO with two variables

public Student(String name, int age) {
this.name = name;
this.age = age;
}

// Getter for name

public String getName() {
return name;
}
 // Setter for name
public void setName(String name) {
this.name = name;
}

// Getter for age

public int getAge() {
return age;
}

// Setter for age

public void setAge(int age) {
this.age = age;
}

// Method to display student details

public void displayDetails() {
System.out.println("Name: " + name);
System.out.println("Age: " + age);
}
}
2. Main Class to Test POJO:

public class Main {

public static void main(String[] args) {

// Creating a Student object (POJO) with 2 variables

Student student1 = new Student("John Doe", 20);

// Accessing POJO data using getter methods

System.out.println("Student Details (Using Getters):");

System.out.println("Name: " + student1.getName());

System.out.println("Age: " + student1.getAge());

 // Displaying details using a method inside POJO

System.out.println("\nStudent Details (Using displayDetails method):");

student1.displayDetails();

// Modifying the student's age using the setter method

student1.setAge(21);

System.out.println("\nUpdated Age:");

System.out.println("Age: " + student1.getAge());

14.Compare and contrast the Setter Dependency Injection with Constructor

Dependency Injection.

Setter Dependency Injection vs Constructor Dependency Injection

Dependency Injection (DI) is a design pattern that allows an object to receive its
dependencies (other objects it works with) rather than creating them itself. This
helps in making the code more modular, testable, and flexible. There are two
common types of dependency injection in Spring (and other DI frameworks):
Setter Dependency Injection and Constructor Dependency Injection.

Let's compare and contrast these two types of dependency injection in detail.

1. Constructor Dependency Injection:

Definition: Constructor Dependency Injection means that the dependencies

(objects) required by a class are provided via its constructor. When the object is
created, the dependencies are injected through the constructor.

How it works:

 The class defines dependencies as constructor parameters.

 These dependencies are passed at the time of object creation.
Advantages:

1. Immutability: Once an object is constructed, it cannot be modified,

ensuring that the injected dependencies are final and cannot be changed
after the object is created.
2. Mandatory Dependencies: If a dependency is required, it must be passed in
the constructor. This ensures that the object is in a valid state upon creation.
3. Easier to Test: Constructor injection makes it clear what dependencies an
object has, making it easier to test, especially when using unit tests.

Disadvantages:

1. Limited Flexibility: If a class has many dependencies, the constructor may

become overloaded, making the code harder to maintain.
2. Difficult to Modify: If the dependencies change, the class signature
(constructor) also needs to be modified.

Example:

// Dependency Class
public class Engine {
public void start() {
System.out.println("Engine started");
}
}

// Class with Constructor Dependency Injection

public class Car {
private Engine engine;

// Constructor that accepts Engine dependency

public Car(Engine engine) {
this.engine = engine;
}
 public void drive() {
engine.start();
System.out.println("Car is driving");
}
}

// Main Class
public class Main {
public static void main(String[] args) {
// Creating the Engine object
Engine engine = new Engine();

// Injecting the Engine dependency into Car using the constructor

Car car = new Car(engine);
car.drive(); // Output: Engine started \n Car is driving
}
}

2. Setter Dependency Injection:

Definition: Setter Dependency Injection means that the dependencies are provided
to a class using setter methods after the object is created.

How it works:

 The class defines setter methods for each dependency.

 These setter methods are called after the object is created, allowing the DI
framework to inject the dependencies.

Advantages:

1. Flexibility: The dependencies can be modified after the object is created.

2. Optional Dependencies: If a dependency is not critical, it can be set later
using the setter method. This allows the object to be created in stages.
 3. Easier to Add New Dependencies: New dependencies can be added
without changing the constructor signature, reducing the need for
refactoring the existing code.

Disadvantages:

1. Mutability: Since dependencies can be set after the object is created, the
object might be in an incomplete or invalid state if all dependencies are not
set.
2. Hidden Dependencies: The class does not explicitly declare its
dependencies in the constructor, making it less obvious what dependencies
the class needs.
3. Difficult to Ensure Correct Initialization: If the dependencies are not set
properly before the object is used, it may lead to errors during runtime.

Example:

// Dependency Class

public class Engine {

public void start() {

System.out.println("Engine started");

// Class with Setter Dependency Injection

public class Car {

private Engine engine;

// Setter method to inject Engine dependency

public void setEngine(Engine engine) {

this.engine = engine;

}
 public void drive() {

if (engine != null) {

engine.start();

System.out.println("Car is driving");

} else {

System.out.println("Engine is not set!");

// Main Class

public class Main {

public static void main(String[] args) {

// Creating the Car object (without Engine initially)

Car car = new Car();

// Setting the Engine dependency using setter method

Engine engine = new Engine();

car.setEngine(engine);

// Drive the car

car.drive(); // Output: Engine started \n Car is driving