11/28/24, 10:56 AM Unit-1:Java programming – B.C.

A study

B.C.A study

Unit-1:Java programming

Java is a popular, high-level programming language that is used to develop a wide range of
applications, from desktop applications to mobile and web applications. Java is known for its
simplicity, portability, and security features, making it an ideal choice for developers.

Here’s an example of how you could use Java to write a simple program that outputs the message
“Hello, World!” to the console:

public class HelloWorld {

public static void main(String[] args) {
[Link](“Hello, World!”);
}
}

This program declares a class named HelloWorld that contains a method named main. The main
method is the entry point of the program and is executed when the program is run. In this case, the
main method prints the message “Hello, World!” to the console.

To run this program, you would save it to a file with a .java extension and then compile it using the
Java compiler. Once the program is compiled, you can run the compiled code to see the output.

Java is an object-oriented programming language, which means that it uses objects and classes to
structure data and behavior. Java also supports multithreading, making it easy to write programs
that can perform multiple tasks at the same time.

Java is widely used for developing applications, particularly for enterprise applications, and is one of
the most popular programming languages in the world. Whether you’re a beginner or an experienced
programmer, Java offers many tools and features to help you build high-quality, efficient
applications.

data types

In Java, data types are used to define the type of a variable, which determines the size and layout of
the variable’s memory, the range of values that can be stored within that memory, and the set of
operations that can be applied to the variable.

1. Primitive Data Types: Java has eight primitive data types, including:
[Link] 1/10
11/28/24, 10:56 AM Unit-1:Java programming – B.C.A study

int: integer type that can store whole numbers from -2^31 to 2^31-1.
long: long integer type that can store whole numbers from -2^63 to 2^63-1.
foat: single-precision floating-point type that can store fractional numbers with a maximum of
7 significant digits.
double: double-precision floating-point type that can store fractional numbers with a
maximum of 16 significant digits.
char: character type that can store a single Unicode character.
boolean: boolean type that can store either true or false.
byte: 8-bit signed integer type that can store values from -128 to 127.
short: 16-bit signed integer type that can store values from -32,768 to 32,767.
2. Non-Primitive Data Types:
String: A string is a sequence of characters, and it is immutable, meaning its value cannot be
changed once created.
Array: An array is a collection of similar elements of the same data type.
Class: A class is a blueprint for creating objects. It defines a set of attributes and methods that
objects of that class type can have.
Interface: An interface is a blueprint for a class, specifying a set of methods that the class must
implement.

Note that all of the primitive data types are passed by value, meaning that when you pass a primitive
value to a method, a copy of the value is created, and any changes made to the value within the
method do not affect the original value. In contrast, non-primitive data types, such as strings and
arrays, are passed by reference, meaning that when you pass an object to a method, the method
receives a reference to the object, not a copy of the object, and any changes made to the object within
the method will be reflected in the original object

control structures

In Java, control structures are used to control the flow of execution in a program, depending on the
values of variables and the results of expressions. There are three main types of control structures:

1. Conditional statements:
if: The if statement is used to execute a block of code only if a certain condition is true.
if-else: The if-else statement is used to execute one block of code if a condition is true and
another block of code if the condition is false.
switch: The switch statement is used to select one of many blocks of code to be executed.
2. Looping structures:
while: The while loop is used to repeat a block of code while a condition is true.
do-while: The do-while loop is similar to the while loop, but it executes the block of code at
least once and then repeats it while the condition is true.
for: The for loop is used to repeat a block of code a specified number of times.
3. Jump statements:
break: The break statement is used to exit a loop early, before the condition is false.
continue: The continue statement is used to skip the current iteration of a loop and proceed to
the next iteration.
return: The return statement is used to exit a method and return a value.

[Link] 2/10
11/28/24, 10:56 AM Unit-1:Java programming – B.C.A study

These control structures allow developers to write flexible, efficient, and readable code that can
respond to various conditions and perform complex operations. Proper use of control structures can
greatly simplify the development process and help prevent bugs

Arrays

In Java, an array is a collection of elements of the same data type. Arrays are used to store multiple
values in a single variable. To declare an array, you need to specify the data type of the elements it
will store and its name, followed by square brackets. Here’s an example:

int[] numbers = new int[5];

In this example, the array “numbers” has been declared to store elements of type “int” and has a
length of 5. This means that it can store 5 integer values.

You can initialize an array with values at the time of declaration like this:

int[] numbers = {1, 2, 3, 4, 5};

You can access the elements of an array using their indices, which start from 0. Here’s an example:

int firstNumber = numbers[0];

int secondNumber = numbers[1];

You can also modify the values of an array using their indices:

numbers[2] = 6;

Arrays can be useful in many different situations, such as:

Storing a list of values, such as the marks of students in a class

Storing a set of related values, such as the prices of items in a shopping cart
Iterating over a set of values, such as printing all the elements of an array on the screen

Arrays can have one or more dimensions, and multi-dimensional arrays can be declared by adding
multiple sets of square brackets. For example:

int[][] twoDimensionalArray = new int[3][3];

This declares a two-dimensional array of type int with 3 rows and 3 columns. To access elements in a
multi-dimensional array, you need to specify two indices, one for the row and one for the column.

In conclusion, arrays are an important concept in Java and are widely used in many different
applications. Understanding how to declare, initialize, access, and modify arrays is an essential part
of becoming proficient in Java programming.

[Link] 3/10
11/28/24, 10:56 AM Unit-1:Java programming – B.C.A study

strings

In Java, a string is an object that represents a sequence of characters. Strings are used to store and
manipulate text data, such as names, addresses, and other information.

Strings can be declared and initialized in several ways in Java. One of the most common ways is to
use double quotes to specify a string literal:

String greeting = “Hello, World!”;

In this example, a string variable named “greeting” is declared and initialized with the string literal
“Hello, World!”.

Another way to create a string is to use the String class and its constructor:

char[] helloArray = {‘H’, ‘e’, ‘l’, ‘l’, ‘o’};

String helloString = new String(helloArray);

In this example, an array of characters is created, and a string is created from the characters in the
array using the String constructor.

Once you have a string, you can perform various operations on it. For example, you can concatenate
two strings using the + operator:

String fullName = “John ” + “Doe”;

in this example, the strings “John ” and “Doe” are concatenated to form a new string “John Doe”.

You can also find the length of a string using the length() method:

int length = [Link]();

In this example, the length of the string “greeting” is found and stored in the variable “length”.

You can also access individual characters in a string using the square bracket [] operator

char firstCharacter = [Link](0);

In this example, the first character of the string “greeting” is accessed and stored in the variable
“firstCharacter”.

In conclusion, strings are a fundamental part of Java programming and are widely used in many
different applications. Understanding how to declare, initialize, manipulate, and access strings is an
essential part of becoming proficient in Java programming.

[Link] 4/10
11/28/24, 10:56 AM Unit-1:Java programming – B.C.A study

Vector

In Java, a Vector is a collection class that implements a dynamic array. It is similar to an ArrayList,
but it is synchronized, which means that it is thread-safe. This means that multiple threads can access
a Vector at the same time without the risk of data corruption.

Here’s an example of how to create and use a Vector in Java:

import [Link];

Vector numbers = new Vector();

[Link](1);
[Link](2);
[Link](3);

[Link](“First element: ” + [Link](0));

[Link](“Second element: ” + [Link](1));
[Link](“Third element: ” + [Link](2));

In this example, a Vector of type Integer is created using the Vector class. The add method is used to
add elements to the Vector, and the get method is used to retrieve elements from the Vector using an
index.

You can also perform various other operations on a Vector, such as:

Removing elements using the remove method

Inserting elements at a specific position using the insertElementAt method
Finding the size of a Vector using the size method

In conclusion, Vectors are a useful collection class in Java, especially when you need a dynamic array
that is synchronized and thread-safe. Understanding how to create and use Vectors is an important
part of becoming proficient in Java programming

classes

A class in Java is a blueprint or a template for creating objects. It defines a set of attributes (instance
variables) and methods that describe the behavior of the objects created from the class. Classes are
the building blocks of object-oriented programming and are used to model real-world concepts, such
as animals, cars, and people.

Here’s a simple example of a class in Java:

public class Dog {

private String breed;
private int age;

[Link] 5/10
11/28/24, 10:56 AM Unit-1:Java programming – B.C.A study

public Dog(String breed, int age) {

[Link] = breed;
[Link] = age;
}

public void bark() {

[Link](“Woof!”);
}

public void printInfo() {

[Link](“Breed: ” + breed + “, Age: ” + age);
}
}

In this example, the class Dog defines two instance variables breed and age that represent the breed
and age of a dog, respectively. The class also has two methods bark and printInfo that define the
behavior of a dog. The bark method simply prints “Woof!” to the console, and the printInfo
method prints the breed and age of a dog.

To create an object from a class, you can use the new operator, followed by the constructor of the
class:

Dog myDog = new Dog(“Labrador”, 5);

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

In this example, an object of the class Dog is created and assigned to the variable myDog. The new
operator is used to call the constructor of the class and create a new instance of the class. The bark
and printInfo methods are then called on the myDog object to demonstrate the behavior of the
object.

In conclusion, classes are a fundamental concept in Java programming and form the backbone of
object-oriented programming. Understanding how to create classes and objects, as well as how to use
inheritance, polymorphism, and encapsulation, is an essential part of becoming proficient in Java
programming.

inheritance

Inheritance is a key feature of object-oriented programming (OOP) that allows you to define a new
class that inherits properties and behavior from an existing class. This allows you to create a new
class that is a specialized version of an existing class.

In Java, inheritance is implemented using the extends keyword. When a class inherits from another
class, it is called the subclass and the class it inherits from is called the superclass. The subclass
automatically inherits all of the instance variables and methods of the superclass.

Here’s an example of inheritance in Java:

class Animal {
private String name;
[Link] 6/10
11/28/24, 10:56 AM Unit-1:Java programming – B.C.A study

public Animal(String name) {

[Link] = name;
}

public void move() {

[Link](“Animal is moving.”);
}
}

class Dog extends Animal {

private String breed;

public Dog(String name, String breed) {

super(name);
[Link] = breed;
}

public void bark() {

[Link](“Woof!”);
}
}

In this example, the class Animal is the superclass and the class Dog is the subclass. The Dog class
inherits the name instance variable and the move method from the Animal class using the extends
keyword. The Dog class also adds a new instance variable breed and a new method bark.

To use inheritance, you can create an object of the subclass and access both the inherited properties
and behavior, as well as the new properties and behavior defined by the subclass:

Dog myDog = new Dog(“Max”, “Labrador”);

[Link]();
[Link]();
[Link](“Name: ” + [Link]());

In this example, an object of the Dog class is created and assigned to the variable myDog. The move
method is called on the myDog object, which is inherited from the Animal class. The bark method is
also called on the myDog object, which is defined by the Dog class.

In conclusion, inheritance is a powerful feature of Java that allows you to create new classes that
inherit properties and behavior from existing classes. This helps you to write reusable and
maintainable code, and is an important part of becoming proficient in Java programming.

packages

A package in Java is a collection of related classes and interfaces. Packages provide a way to organize
and structure your code, making it easier to manage and reuse. Packages also help to prevent naming
conflicts between classes by ensuring that each class has a unique name within the package.

To create a package, you use the package keyword followed by the name of the package at the
beginning of your code file:
[Link] 7/10
11/28/24, 10:56 AM Unit-1:Java programming – B.C.A study

package [Link];

public class MyClass {

…
}

In this example, the class MyClass is part of the [Link] package.

To use a class from a package in your code, you need to import the class using the import keyword:

import [Link];

public class Main {

public static void main(String[] args) {
MyClass myObject = new MyClass();
…
}
}

In this example, the MyClass class is imported from the [Link] package, and a
new instance of the MyClass class is created and assigned to the variable myObject.

It’s worth noting that the Java standard library includes many useful packages, such as [Link]
for collections and data structures, [Link] for input and output, and [Link] for network
programming.

In conclusion, packages are an important part of Java programming, providing a way to organize and
structure your code, making it easier to manage and reuse. By using packages, you can make your
code more organized and maintainable, and reduce the risk of naming conflicts between classes.

exception handling

Exception handling is a process in computer programming that allows a program to handle errors or
unexpected events gracefully, instead of crashing or producing incorrect results. It is done through
the use of exceptions, which are objects that represent an error condition.

Here is an example of exception handling in Python:

try:
# code that may raise an exception
result = 10 / 0
except ZeroDivisionError:
# code to handle the exception
print(“Cannot divide by zero”)
finally:
# this block of code will always be executed
print(“This is the finally block”)

[Link] 8/10
11/28/24, 10:56 AM Unit-1:Java programming – B.C.A study

In this example, we are trying to divide 10 by 0, which will result in a ZeroDivisionError

exception. The try block contains the code that may raise the exception. The except block contains
the code that will handle the exception if it occurs. The finally block contains code that will always
be executed, regardless of whether an exception occurred or not.

multithreaded programming

Multithreaded programming is a programming technique that allows a single program to have

multiple threads of execution, each running concurrently and independently. This allows for greater
parallelism and can make the program more efficient, as multiple tasks can be performed
simultaneously.

Here is an example of multithreaded programming in Python:

import threading

def worker():
print(“Worker thread starting”)

create the worker thread

thread = [Link](target=worker)

start the worker thread

[Link]()

main thread continues here

print(“Main thread continuing”)

In this example, we define a function worker that will run in a separate thread. We then create a
Thread object, passing the worker function as the target. Finally, we call the start method on the
Thread object to start the worker thread. The main thread continues to run and print “Main thread
continuing”, while the worker thread runs and prints “Worker thread starting”.

examples of multithread programming

Extending the Thread class:

class WorkerThread extends Thread {

public void run() {
[Link](“Worker thread starting”);
}
}

[Link] 9/10
11/28/24, 10:56 AM Unit-1:Java programming – B.C.A study

public class Main {

public static void main(String[] args) {
WorkerThread worker = new WorkerThread();
[Link]();
[Link](“Main thread continuing”);
}
}

Here are some examples of multithreaded programming in Java:

1. Extending the Thread class:

csharpCopy codeclass WorkerThread extends Thread {

public void run() {
[Link]("Worker thread starting");
}
}

public class Main {

public static void main(String[] args) {
WorkerThread worker = new WorkerThread();
[Link]();
[Link]("Main thread continuing");
}
}

2. Implementing the Runnable interface:

class WorkerRunnable implements Runnable {

public void run() {
[Link](“Worker thread starting”);
}
}

public class Main {

public static void main(String[] args) {
Thread worker = new Thread(new WorkerRunnable());
[Link]();
[Link](“Main thread continuing”);
}
}

In both of these examples, the run method contains the code that will be executed in the worker
thread. The start method is called on the Thread object to start the worker thread. The main thread
continues to run and print “Main thread continuing”, while the worker thread runs and prints
“Worker thread starting”.


A [Link] Website.

[Link] 10/10
11/28/24, 10:56 AM Unit-2: Java Applets – B.C.A study

B.C.A study

Unit-2: Java Applets

Java applets are small, self-contained Java programs that run within a web browser. They are
designed to be executed within a web page, dynamically loaded and embedded within an HTML
document.

Here’s an example of a simple Java applet that displays a message:

import [Link].; import [Link].;

public class HelloApplet extends Applet {

public void paint(Graphics g) {
[Link](“Hello, World!”, 50, 25);
}
}

To run the applet, you would need to include the following HTML code in a web page:

<applet code=”[Link]” width=”300″ height=”300″> </applet>

When the web page loads, the Java applet is executed within the browser window, and the message
“Hello, World!” is displayed.

AWT controls

Abstract Window Toolkit (AWT) is a set of Java classes that provides a platform-independent way of
creating graphical user interfaces (GUIs) for Java applications. It was the first GUI toolkit available for
the Java platform and is part of the Java Standard Edition (SE).

Here are some of the commonly used AWT controls and their functions:

1. Button: A button is a control that triggers an action when clicked. It is represented by the Button
class.
2. Label: A label is used to display text or an image. It is represented by the Label class.
3. TextField: A text field is a control used to input a single line of text. It is represented by the
TextField class.
4. TextArea: A text area is a control used to input or display multiple lines of text. It is represented
by the TextArea class.
[Link] 1/11
11/28/24, 10:56 AM Unit-2: Java Applets – B.C.A study

5. Checkbox: A checkbox is a control that allows the user to make a binary choice. It is represented
by the Checkbox class.
6. RadioButton: A radio button is used to present a mutually exclusive set of options to the user. It is
represented by the RadioButton class.
7. Choice: A choice is a control used to present a drop-down list of options to the user. It is
represented by the Choice class.
8. List: A list is a control that displays a scrollable list of items. It is represented by the List class.
9. Scrollbar: A scrollbar is a control used to allow the user to scroll through a range of values. It is
represented by the Scrollbar class.
10. Menu: A menu is a control used to present a list of options to the user. It is represented by the
Menu and MenuItem classes.

These are some of the basic controls provided by AWT. There are also more advanced controls, such
as panels, dialogs, and frames, that can be used to create more complex GUIs

button

A button in Java is a control component that triggers an action when clicked. It is represented by the
[Link] class in the Abstract Window Toolkit (AWT).

Here’s an example of how you could create a button in Java using the AWT:

import [Link].; import [Link].;

public class ButtonExample extends Frame implements ActionListener {

private Button btn;
private Label lbl;

public ButtonExample() {
setLayout(new FlowLayout());

1 btn = new Button("Click me");

2 add(btn);
3 [Link](this);
4
5 lbl = new Label("Welcome to Java");
6 add(lbl);
7
8 setSize(300, 300);
9 setVisible(true);

public void actionPerformed(ActionEvent e) {

[Link](“Button clicked!”);
}

public static void main(String[] args) {

new ButtonExample();
}
[Link] 2/11
11/28/24, 10:56 AM Unit-2: Java Applets – B.C.A study

In the example, we first create a Button object and add it to the Frame. Then, we implement the
ActionListener interface and override the actionPerformed method to handle the button click
event. In the actionPerformed method, we update the text of a Label component to indicate that
the button has been clicked.

When the program is run, a window containing the button and label will be displayed. When the
button is clicked, the text of the label will change to “Button clicked!

Labels

Labels in java with example

A label in Java is a control component that displays text or an image. It is represented by the
[Link] class in the Abstract Window Toolkit (AWT).

Here’s an example of how you could create a label in Java using the AWT:

import [Link].*;

public class LabelExample extends Frame {

public LabelExample() {
setLayout(new FlowLayout());

1 Label label1 = new Label("This is label 1");

2 add(label1);
3
4 Label label2 = new Label("This is label 2");
5 [Link]([Link]);
6 add(label2);
7
8 setSize(300, 300);
9 setVisible(true);

public static void main(String[] args) {

new LabelExample();
}
}

In the example, we create two Label objects and add them to the Frame. The first label displays the
text “This is label 1”. The second label displays the text “This is label 2” and its alignment is set to
right.

When the program is run, a window containing the two labels will be displayed, with the first label
aligned to the left and the second label aligned to the right.

[Link] 3/11
11/28/24, 10:56 AM Unit-2: Java Applets – B.C.A study

combo box

A combo box in Java is a control component that allows the user to select an item from a drop-down
list of options. It is represented by the [Link] class in the Abstract Window Toolkit
(AWT).

Here’s an example of how you could create a combo box in Java using the AWT:

import [Link].; import [Link].;

public class ComboBoxExample extends Frame implements ItemListener {

private Choice choice;
private Label lbl;

public ComboBoxExample() {
setLayout(new FlowLayout());

1 choice = new Choice();

2 [Link]("Option 1");
3 [Link]("Option 2");
4 [Link]("Option 3");
5 add(choice);
6 [Link](this);
7
8 lbl = new Label("Welcome to Java");
9 add(lbl);
10
11 setSize(300, 300);
12 setVisible(true);

public void itemStateChanged(ItemEvent e) {

[Link](“You selected ” + [Link]());
}

public static void main(String[] args) {

new ComboBoxExample();
}
}

In the example, we create a Choice object and add several options to it. Then, we implement the
ItemListener interface and override the itemStateChanged method to handle the selection event.
In the itemStateChanged method, we update the text of a Label component to indicate the selected
option.

When the program is run, a window containing the combo box and label will be displayed. When an
option is selected from the combo box, the text of the label will change to display the selected option.

[Link] 4/11
11/28/24, 10:56 AM Unit-2: Java Applets – B.C.A study

list and other Listeners

Listeners in Java are components that respond to specific events, such as a user clicking a button or
selecting an item from a list. The Java Abstract Window Toolkit (AWT) provides several types of
listeners, including:

1. ActionListener: triggers an action when a button or menu item is clicked.

2. ItemListener: triggers an action when an item is selected from a list or combo box.
3. WindowListener: triggers an action when a window is opened, closed, activated, or deactivated.
4. KeyListener: triggers an action when a key is pressed or released.
5. MouseListener: triggers an action when a mouse button is clicked or the mouse pointer is
moved.

Here’s an example of how you could use the ActionListener interface:

import [Link].; import [Link].;

public class ActionListenerExample extends Frame implements ActionListener {

private Button btn;
private Label lbl;

public ActionListenerExample() {
setLayout(new FlowLayout());

1 btn = new Button("Click me");

2 add(btn);
3 [Link](this);
4
5 lbl = new Label("Welcome to Java");
6 add(lbl);
7
8 setSize(300, 300);
9 setVisible(true);

public void actionPerformed(ActionEvent e) {

[Link](“Button clicked!”);
}

public static void main(String[] args) {

new ActionListenerExample();
}
}

In the example, we create a Button object and add it to the Frame. Then, we implement the
ActionListener interface and override the actionPerformed method to handle the button click
event. In the actionPerformed method, we update the text of a Label component to indicate that
the button has been clicked.

[Link] 5/11
11/28/24, 10:56 AM Unit-2: Java Applets – B.C.A study

Similarly, you could use the other listener interfaces in Java to handle different types of events. For
example, you could use the ItemListener interface to handle the selection event of a list or combo
box, the WindowListener interface to handle the window events, the KeyListener interface to
handle the key events, and the MouseListener interface to handle the mouse events.

menu bar

A menu bar in Java is a component that provides a container for multiple menus. It is represented by
the [Link] class in the Abstract Window Toolkit (AWT).

Here’s an example of how you could create a menu bar in Java using the AWT:

import [Link].; import [Link].;

public class MenuBarExample extends Frame {

private MenuBar menuBar;
private Menu fileMenu;
private MenuItem exitItem;

public MenuBarExample() {
setLayout(new FlowLayout());

1 menuBar = new MenuBar();

2 setMenuBar(menuBar);
3
4 fileMenu = new Menu("File");
5 [Link](fileMenu);
6
7 exitItem = new MenuItem("Exit");
8 [Link](exitItem);
9 [Link](new ActionListener() {
10 public void actionPerformed(ActionEvent e) {
11 [Link](0);
12 }
13 });
14
15 setSize(300, 300);
16 setVisible(true);

public static void main(String[] args) {

new MenuBarExample();
}
}

In the example, we create a MenuBar object and set it as the menu bar for the Frame. Then, we create a
Menu object and add it to the menu bar. Finally, we create a MenuItem object, add it to the menu, and
set an ActionListener to handle the exit event. When the program is run, a window containing the

[Link] 6/11
11/28/24, 10:56 AM Unit-2: Java Applets – B.C.A study

menu bar will be displayed. When the “Exit” option is selected from the “File” menu, the program
will exit.

Note that in the example, the ActionListener is implemented using an anonymous inner class.
Alternatively, you could implement the ActionListener interface in a separate class and create an
instance of that class to handle the event.

layout manager

A layout manager in Java is a component that controls the placement and size of components within
a container. Java provides several layout managers, including FlowLayout, BorderLayout,
GridLayout, BoxLayout, CardLayout, and GridBagLayout, among others.

Here’s an example of how you could use the FlowLayout layout manager:

import [Link].*;

public class FlowLayoutExample extends Frame {

private Button btn1, btn2, btn3;

public FlowLayoutExample() {
setLayout(new FlowLayout());

1 btn1 = new Button("Button 1");

2 add(btn1);
3
4 btn2 = new Button("Button 2");
5 add(btn2);
6
7 btn3 = new Button("Button 3");
8 add(btn3);
9
10 setSize(300, 300);
11 setVisible(true);

public static void main(String[] args) {

new FlowLayoutExample();
}
}

A layout manager in Java is a component that controls the placement and size of components within
a container. Java provides several layout managers, including FlowLayout, BorderLayout,
GridLayout, BoxLayout, CardLayout, and GridBagLayout, among others.

Here’s an example of how you could use the FlowLayout layout manager:

[Link] 7/11
11/28/24, 10:56 AM Unit-2: Java Applets – B.C.A study

javaCopy codeimport [Link].*;

public class FlowLayoutExample extends Frame {

private Button btn1, btn2, btn3;

public FlowLayoutExample() {
setLayout(new FlowLayout());

btn1 = new Button("Button 1");

add(btn1);

btn2 = new Button("Button 2");

add(btn2);

btn3 = new Button("Button 3");

add(btn3);

setSize(300, 300);
setVisible(true);
}

public static void main(String[] args) {

new FlowLayoutExample();
}
}

In the example, we create a Frame object and set its layout manager to a FlowLayout object. Then, we
create three Button objects and add them to the frame. When the program is run, the buttons will be
displayed in a flow layout, which means they will be placed one after the other in a row, left to right.
If there isn’t enough space in the row for all the buttons, a new row will be started.

Similarly, you could use other layout managers in Java to arrange the components in different ways.
For example, you could use the BorderLayout layout manager to arrange components in the north,
south, east, west, and center regions of a container, or you could use the GridLayout layout manager
to arrange components in a grid with a specified number of rows and columns.

string handling

String handling in Java involves performing operations on strings, such as concatenation,

comparison, searching, replacing, and others. Here are some of the main string handling functions in
Java along with examples:

1. Concatenation:

[Link] 8/11
11/28/24, 10:56 AM Unit-2: Java Applets – B.C.A study

String str1 = “Hello”;

String str2 = “World”;
String str3 = str1 + ” ” + str2;
[Link](str3); // Output: Hello World

2. Comparison:

String str1 = “Hello”;

String str2 = “Hello”;
if ([Link](str2)) {
[Link](“The strings are equal.”);
}
else {
[Link](“The strings are not equal.”);
}

3. Searching:

String str = “Hello World”;

int index = [Link](“World”);
[Link](“Index of World: ” + index); // Output: 6

4. Replacing:

String str = “Hello World”;

str = [Link](“World”, “Java”);
[Link](str); // Output: Hello Java

String handling in Java involves performing operations on strings, such as concatenation,

comparison, searching, replacing, and others. Here are some of the main string handling functions in
Java along with examples:

1. Concatenation:

javascriptCopy codeString str1 = "Hello";

String str2 = "World";
String str3 = str1 + " " + str2;
[Link](str3); // Output: Hello World

2. Comparison:

[Link] 9/11
11/28/24, 10:56 AM Unit-2: Java Applets – B.C.A study

csharpCopy codeString str1 = "Hello";

String str2 = "Hello";
if ([Link](str2)) {
[Link]("The strings are equal.");
}
else {
[Link]("The strings are not equal.");
}

3. Searching:

perlCopy codeString str = "Hello World";

int index = [Link]("World");
[Link]("Index of World: " + index); // Output: 6

4. Replacing:

rustCopy codeString str = "Hello World";

str = [Link]("World", "Java");
[Link](str); // Output: Hello Java

5. Substring:

String str = “Hello World”;

String sub = [Link](6);
[Link](sub); // Output: World

6. Trimming:

String str = ” Hello World “;

str = [Link]();
[Link](str); // Output: Hello World

[Link]

String str = “Hello World”;

int len = [Link]();
[Link](“Length of the string: ” + len); // Output: 11

8. Conversion:

int i = 42;
String str = [Link](i);
[Link](str); // Output: 42

[Link] 10/11
11/28/24, 10:56 AM Unit-2: Java Applets – B.C.A study

These are some of the main string handling functions in Java. You can use these functions to
manipulate strings in your Java programs as needed.


A [Link] Website.

[Link] 11/11
11/28/24, 10:56 AM Unit-3: Networking – B.C.A study

B.C.A study

Unit-3: Networking

Networking in Java refers to the process of connecting two or more devices together over a network
to exchange data and communicate with each other. In Java, networking is implemented using the
[Link] package, which provides a set of classes and interfaces for building network-based
applications.

Some commonly used classes for network programming in Java include:

Socket: used for creating a connection between a client and a server.

ServerSocket: used for creating a server that listens for incoming client connections.
URL: used for accessing resources over the Internet using the HTTP or FTP protocols.
URLConnection: used for sending and receiving data from a URL.
InetAddress: used for working with IP addresses.

These classes provide a high-level API for networking in Java, making it easy to build network-based
applications that can run on any platform

Datagram Socket: A datagram socket is a type of network socket that uses the User Datagram
Protocol (UDP) to transmit data over a network. In Java, the DatagramSocket class is used to
implement datagram sockets.

UDP is a connectionless protocol, meaning that it does not establish a reliable connection between
two devices. Instead, it sends data in the form of individual packets, called datagrams, which may
arrive out of order or not at all. This makes UDP well suited for applications that require fast, real-
time communication and can tolerate some loss of data, such as video and audio streaming.

TCP/IP based Server Socket: A TCP/IP based server socket is a type of network socket that uses the
Transmission Control Protocol (TCP) to transmit data over a network. In Java, the ServerSocket class
is used to implement TCP/IP server sockets.

TCP is a reliable, connection-oriented protocol that establishes a reliable, bi-directional

communication channel between two devices. When a client connects to a server, a socket is created
on both the client and server devices, allowing them to send and receive data. Unlike UDP, TCP
ensures that all data is transmitted in the correct order and retransmits any lost data, making it well
suited for applications that require reliable data transfer, such as file transfers and email.

Both datagram sockets and TCP/IP based server sockets are useful for different types of network
applications, and the choice between the two will depend on the specific requirements of the
application.

[Link] 1/2
11/28/24, 10:56 AM Unit-3: Networking – B.C.A study

datagram socket and TCP/IP based server socket

A [Link] Website.

[Link] 2/2
JDBC: Introduction, Drivers, Establishing Connection, Connection Pooling.

JDBC: Introduction
JDBC (Java Database Connectivity) is an API that allows Java applications to
interact with databases. It provides methods to query and update data in a
database, and is a part of the Java Standard Edition platform.
JDBC Drivers
JDBC drivers are the bridge between your Java application and the database. There
are four types of JDBC drivers:
1. JDBC-ODBC Bridge Driver: Translates JDBC calls into ODBC calls.
2. Native-API Driver: Converts JDBC calls into database-specific calls.
3. Network Protocol Driver: Uses middleware to convert JDBC calls into database-
specific calls.
4. Thin Driver: Converts JDBC calls directly into the database-specific protocol.

Establishing Connection
To establish a connection to a database, you typically follow these steps:
1. Load the JDBC Driver: Use `[Link]("[Link]")` to load the
driver.
2. Create a Connection: Use `[Link](url, user, password)`
to establish a connection to the database.
3. Create a Statement: Use `[Link]()` to create a statement
object.
4. Execute Queries: Use `[Link](sql)` for SELECT queries or
`[Link](sql)` for INSERT, UPDATE, DELETE queries.
5. Close the Connection: Always close the connection using `[Link]()` to
free up resources.
Connection Pooling
Connection pooling is a technique used to improve performance by reusing
database connections. Instead of creating a new connection every time, a pool of
connections is maintained and reused. This reduces the overhead of establishing a
connection and improves the application's performance.
Here's a simple example of how you might use JDBC in a Java application:
Code:-
import [Link];
import [Link];
import [Link];
import [Link];

public class JDBCExample {

public static void main(String[] args) {
try {
// Load the JDBC driver
[Link]("[Link]");

// Establish a connection
Connection connection =
[Link]("jdbc:mysql://localhost:3306/mydatabase",
"user", "password");

// Create a statement
Statement statement = [Link]();
 // Execute a query
ResultSet resultSet = [Link]("SELECT * FROM mytable");

// Process the result set

while ([Link]()) {
[Link]("Column1: " + [Link]("column1"));
[Link]("Column2: " + [Link]("column2"));
}

// Close the connection

[Link]();
} catch (Exception e) {
[Link]();
}
}
}
```

This code demonstrates loading the JDBC driver, establishing a connection,

creating a statement, executing a query, processing the result set, and closing the
connection. Connection pooling would typically be handled by a framework or
library, such as Apache DBCP or HikariCP, to manage the pool of connections
efficiently.
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
11/28/24, 11:02 AM Unit-5: Java servlets – B.C.A study

B.C.A study

Unit-5: Java servlets

Java Servlets are server-side Java components that allow dynamic generation of HTML pages,
handling HTTP requests and generating dynamic web pages. They provide a platform-independent,
secure and efficient way of creating web applications. Servlets run on a web server, receiving requests
from clients (typically web browsers) and returning responses back to the clients.

Servlets are part of the Java EE (Enterprise Edition) platform, and they are used for building robust
and scalable web applications. Servlets are well suited for handling dynamic requests that require the
processing of data and the generation of HTML content. They can interact with databases, access
APIs, and perform complex operations, making them ideal for web applications that require server-
side processing.

The main advantage of servlets is that they are platform-independent and can run on any web server
that supports the Servlet API. They are also designed to work with Java, making it easier to develop
web applications that can be used on any platform.

Servlets are written in Java, making them easy to maintain and upgrade, and they are also highly
secure. Java provides built-in security features such as access control, encryption, and data validation
that can be used to secure web applications.

To create a servlet, a Java class must be written that extends the [Link] class
and overrides the doGet or doPost method. This method handles HTTP requests and generates the
HTML content to be sent back to the client.

In summary, Java Servlets are a powerful and efficient way of building dynamic web applications
that can run on any platform. They are secure, platform-independent, and easy to maintain, making
them a popular choice for web developers

HTTP Servlets Basics

HTTP Servlets are Java components that are used to handle HTTP requests and generate dynamic
HTML pages. They are an integral part of the Java EE platform and are used for building robust and
scalable web applications.

Basics of HTTP Servlets:

[Link] 1/5
11/28/24, 11:02 AM Unit-5: Java servlets – B.C.A study

1. Extending the HttpServlet class: To create a servlet, you need to write a Java class that extends the
[Link] class. This class provides the basic functionality for handling HTTP
requests and generating HTML responses.
2. Overriding the doGet or doPost method: The servlet class needs to override the doGet or doPost
method to handle HTTP requests. The doGet method is used for handling HTTP GET requests
and the doPost method is used for handling HTTP POST requests.
3. Handling HTTP requests: The doGet or doPost method is called by the web server whenever an
HTTP request is made to the servlet. This method can access the request and response objects to
access the request data and generate a response.
4. Generating HTML responses: The servlet can use the response object to generate HTML content to
be sent back to the client. The response object has methods for setting the HTTP status code,
setting the content type, and adding content to the response.
5. Deployment: Once the servlet is written, it needs to be deployed to a web server that supports the
Servlet API. The servlet can be deployed as a standalone component or as part of a web
application.
6. URL Mapping: To access a servlet, a URL mapping must be created. The URL mapping maps a
URL to a servlet, and when a client requests that URL, the servlet is executed.

In conclusion, HTTP Servlets are a powerful and efficient way of building dynamic web applications.
They provide a platform-independent, secure, and easy-to-maintain way of handling HTTP requests
and generating HTML pages. HTTP Servlets are widely used in the Java EE platform and are an
essential component of many web applications

The Servlets Lifecycle

The Servlets Lifecycle refers to the stages a servlet goes through from its creation to its destruction.
The following are the stages in the Servlets Lifecycle:

1. Loading and Initialization: When a servlet is first deployed, it is loaded into memory by the web
server. The servlet container then calls the init method of the servlet, which is used to initialize the
servlet. This method is called only once in the servlet’s lifecycle.
2. Handling Requests: Once the servlet is initialized, it is ready to handle client requests. The servlet
container calls the service method of the servlet to handle the request. The service method
determines the type of request (GET or POST) and calls the appropriate doGet or doPost method.
3. Generating Responses: The servlet generates a response by writing HTML content to the response
object. The response object is passed to the servlet in the service method. The servlet can use the
response object to set the HTTP status code, set the content type, and add content to the response.
4. Destruction: When the servlet is no longer needed, the servlet container calls the destroy method
to clean up resources used by the servlet. The destroy method is called only once in the servlet’s
lifecycle, just before the servlet is removed from memory.

[Link] 2/5
11/28/24, 11:02 AM Unit-5: Java servlets – B.C.A study

It is important to note that multiple clients can access a single servlet simultaneously. The servlet
container creates a new thread for each client request, and each thread calls the service method of the
servlet. This allows multiple clients to access the servlet simultaneously, without interfering with
each other

Retrieving Information

Retrieving information refers to the process of accessing data or information stored in a database, file
system, or other storage medium. This information can be retrieved in various ways, including:

1. HTTP GET Requests: This is the most common method of retrieving information from a web
server. An HTTP GET request is sent from the client to the server, and the server responds with
the requested information. The information is sent as part of the URL, and the server uses this
information to generate the response.
2. HTTP POST Requests: HTTP POST requests are used to send data from the client to the server.
This method is often used for forms, where the user enters data into a form and submits it to the
server. The server processes the data and generates a response.
3. SQL Queries: SQL (Structured Query Language) is a standard language for accessing and
manipulating data stored in a relational database. SQL queries are used to retrieve information
from a database. The query specifies what data is to be retrieved and how it is to be organized.
4. File I/O: Information can also be retrieved from a file system. This can be done using file I/O
(input/output) operations. The file system is accessed, and the information is read from the file
and stored in memory.
5. REST APIs: REST (Representational State Transfer) APIs are used to retrieve information from a
web server. REST APIs define a set of endpoints that return data in response to client requests.
The client specifies the endpoint and the data to be returned, and the server returns the data

[Link] 3/5
11/28/24, 11:02 AM Unit-5: Java servlets – B.C.A study

Sending HTML Information

Sending HTML information refers to the process of sending data in HTML format from a web server
to a client. HTML (Hypertext Markup Language) is the standard language used for creating web
pages. The following are the steps involved in sending HTML information:

1. Generating HTML content: The HTML content is generated by the server-side code. This can be
done using a variety of methods, including dynamic HTML generation, template engines, and
content management systems.
2. Setting the response content type: The content type of the response must be set to “text/html” to
indicate that the response is in HTML format. This is done by setting the “Content-Type” header
in the response object.
3. Writing HTML content to the response object: The HTML content is written to the response object
using the response object’s “write” method. The “write” method takes the HTML content as a
parameter and writes it to the response.
4. Sending the response to the client: The response is sent to the client by the web server. The client
receives the HTML content and displays it in the browser.

In conclusion, sending HTML information involves generating the HTML content, setting the content
type of the response, writing the HTML content to the response object, and sending the response to
the client. Understanding the steps involved in sending HTML information is essential for building
dynamic web pages and web applications.

Session Tracking

Session tracking refers to the process of maintaining state information for a user across multiple
requests. This is necessary because HTTP is a stateless protocol, meaning that each request is treated
as a separate, independent request. In a web application, it is often necessary to maintain state
information for a user, such as the items in their shopping cart, or their login status.

Session tracking can be achieved in several ways, including:

1. URL rewriting: URL rewriting involves adding a session identifier to the URL of each page. This
session identifier is used to identify the user and maintain their state information across requests.
2. Hidden form fields: Hidden form fields are fields in an HTML form that are not visible to the
user. These fields can be used to store session information, such as a session identifier, that can be
sent back to the server with each request.
3. Cookies: Cookies are small text files that are stored on the client’s machine by the web server.
Cookies can be used to store session information, such as a session identifier, and this information
is sent back to the server with each request.
4. HTTP session: The HTTP session is a mechanism for maintaining state information for a user
across multiple requests. The HTTP session is managed by the servlet container, and it stores
session information in memory on the server.

[Link] 4/5
11/28/24, 11:02 AM Unit-5: Java servlets – B.C.A study

In conclusion, session tracking is an important concept in web development, and it is used to

maintain state information for a user across multiple requests. Understanding the different methods
of session tracking is essential for building robust and scalable web applications

Database Connectivity

Database connectivity refers to the process of connecting to a database from a web application in
order to retrieve and store data. A database connection is required in order to interact with a
database, and there are several methods for establishing a database connection, including:

1. JDBC (Java Database Connectivity): JDBC is a standard API for connecting to databases from Java
applications. JDBC provides a set of classes and interfaces that enable Java applications to interact
with databases.
2. JPA (Java Persistence API): JPA is a Java API for connecting to databases and performing database
operations. JPA is a standard API for Java applications, and it provides a simple and efficient way
to connect to databases and perform database operations.
3. Hibernate: Hibernate is a Java framework for connecting to databases and performing database
operations. Hibernate is a popular framework for Java applications, and it provides a simple and
efficient way to connect to databases and perform database operations.
4. JNDI (Java Naming and Directory Interface): JNDI is a Java API for connecting to databases and
performing database operations. JNDI provides a simple and efficient way to connect to databases
and perform database operations.

database connectivity is an important concept in web development, and it is used to connect to

databases from web applications in order to retrieve and store data. Understanding the different
methods for establishing a database connection is essential for building robust and scalable web
applications


A [Link] Website.

[Link] 5/5
11/28/24, 11:03 AM Unit-6: Java Server Pages – B.C.A study

B.C.A study

Unit-6: Java Server Pages

Java Server Pages (JSP) is a technology for creating dynamic, data-driven web pages. It is based on
Java and uses special tags in HTML to access Java code that can generate dynamic content. JSP is
executed on a web server and the generated HTML is sent to the client’s web browser to be
displayed. JSP is commonly used for creating interactive web sites, e-commerce applications, and
other types of dynamic web content.

Introducing Java Server Pages

Java Server Pages (JSP) is a server-side technology for creating dynamic, data-driven web pages. It is
based on Java and allows developers to embed Java code in HTML pages to generate dynamic
content.

JSP pages are executed on a web server and the output is sent to the client’s web browser as HTML.
JSP is used to create web applications that require dynamic content, such as interactive web sites, e-
commerce applications, and other types of dynamic web content.

JSP provides a number of built-in tags and APIs that make it easy to create dynamic content, access
databases, and perform other tasks commonly required in web applications. JSP also allows
developers to create custom tags, which can be used to encapsulate complex logic and reuse code
across multiple pages.

JSP pages are compiled into Java servlets at runtime, which are then executed on the server. This
provides the performance benefits of a Java-based solution with the simplicity of HTML-based
development.

In summary, Java Server Pages is a powerful technology for creating dynamic web pages that can be
used to create a wide range of web applications. It provides a flexible and extensible framework for
web development and is widely used in the industry for building large-scale web applications

[Link] 1/7
11/28/24, 11:03 AM Unit-6: Java Server Pages – B.C.A study

JSP Overview

JSP (JavaServer Pages) is a technology used to create dynamic web pages. It allows Java code and
HTML to be combined into a single file, with the Java code executed on the server and the resulting
HTML sent to the client’s web browser. JSP provides a simplified, fast way to create dynamic web
pages compared to servlets.

Here’s a simple example of a JSP page:

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

pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Hello JSP</title>
</head>
<body>
<%
String name = "John Doe";
%>
<h1>Hello <%= name %></h1>
</body>
</html>

In this example, the JSP code is enclosed in <% ... %> tags. The code inside the tags is executed on
the server and the result is inserted into the HTML. The line <%= name %> is an expression that
outputs the value of the name variable into the HTML. When the JSP is executed, the resulting HTML
sent to the client’s web browser will be:

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Hello JSP</title>
</head>
<body>
<h1>Hello John Doe</h1>
</body>
</html>

[Link] 2/7
11/28/24, 11:03 AM Unit-6: Java Server Pages – B.C.A study

Setting Up the JSP Environment

To set up the JSP environment, you need to have the following components installed:

1. Java Development Kit (JDK)

2. A Java-enabled web server, such as Apache Tomcat
3. A text editor or integrated development environment (IDE) for writing JSP pages, such as Eclipse
or IntelliJ IDEA

Here’s the general process for setting up a JSP environment:

1. Install JDK: You can download the latest version of the JDK from the Oracle website. After
downloading, follow the instructions to install JDK on your computer.
2. Install a web server: Download and install a Java-enabled web server, such as Apache Tomcat,
from its official website.
3. Set up your text editor or IDE: Install a text editor or IDE that you prefer to use for writing JSP
pages. Many popular IDEs, such as Eclipse and IntelliJ IDEA, have built-in support for JSP
development.
4. Configure the web server: Configure the web server to recognize JSP pages and specify the
location where the JSP pages will be stored. For example, in Apache Tomcat, you can configure
the [Link] file to map the .jsp extension to the JSP servlet.

Once you have completed these steps, you should have a working JSP environment that you can use
to develop and deploy JSP pages

Generating Dynamic Content

JSP is commonly used to generate dynamic content on web pages. This means that the content of a
web page can change based on user input, the current date and time, or other variables.

Here’s an example of how to generate dynamic content using JSP:

[Link] 3/7
11/28/24, 11:03 AM Unit-6: Java Server Pages – B.C.A study

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

pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Dynamic Content</title>
</head>
<body>
<%
[Link] today = new [Link]();
%>
<h1>Current Date and Time</h1>
<p><%= today %></p>
</body>
</html>

In this example, a [Link] object is created to represent the current date and time. The value
of the today variable is then inserted into the HTML using the expression <%= today %>. When the
JSP is executed, the resulting HTML sent to the client’s web browser will display the current date and
time.

This is just a simple example, but you can use JSP to generate dynamic content based on user input,
database queries, or any other source of data. The Java code inside the JSP can perform calculations,
make decisions, and generate HTML based on the data

Using Custom Tag Libraries and the JSP Standard Tag

Library

Custom tag libraries and the JSP Standard Tag Library (JSTL) provide a way to encapsulate complex
and repetitive operations in JSP pages as reusable components. Custom tags can be used to
encapsulate HTML, Java code, and other JSP elements into a single component. The JSTL is a
collection of predefined custom tags that perform common operations, such as conditional
processing, iteration, URL manipulation, and database access.

Here’s an example of using a custom tag in JSP:

[Link] 4/7
11/28/24, 11:03 AM Unit-6: Java Server Pages – B.C.A study

<%@ taglib prefix="my" uri="[Link] %>

<html>
<head>
<title>Custom Tag Example</title>
</head>
<body>
<my:hello />
</body>
</html>

In this example, the <%@ taglib ... %> directive declares that a custom tag library with the prefix
my is used in the JSP page. The uri attribute specifies the location of the tag library definition. When
the JSP is executed, the custom tag <my:hello /> will be processed by the web server and the
corresponding Java code for the tag will be executed.

Here’s an example of using the JSTL in JSP:

<%@ taglib prefix="c" uri="[Link] %>

<html>
<head>
<title>JSTL Example</title>
</head>
<body>
<c:if test="${[Link] != null}">
Hello, <c:out value="${[Link]}" />
</c:if>
</body>
</html>

In this example, the <%@ taglib ... %> directive declares that the JSTL library with the prefix c is
used in the JSP page. The <c:if test="${[Link] != null}"> tag is a conditional processing
tag that checks if the name parameter is present in the request. If the name parameter is present, the
<c:out value="${[Link]}" /> tag outputs the value of the name parameter.

By using custom tags and the JSTL, you can make your JSP pages more readable and maintainable,
and reuse complex operations across multiple pages

[Link] 5/7
11/28/24, 11:03 AM Unit-6: Java Server Pages – B.C.A study

Processing Input and Output.

JSP provides several ways to process input and output in a web application. You can use JSP
expressions and scriptlets to insert dynamic data into the HTML, as well as use form inputs to gather
information from the user.

Here’s an example of processing input in JSP:

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

pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Processing Input</title>
</head>
<body>
<form action="[Link]" method="post">
Name: <input type="text" name="name"><br>
<input type="submit" value="Submit">
</form>
</body>
</html>

In this example, a HTML form with a text input and a submit button is defined. The form’s action
attribute specifies the JSP page that will process the form data, and the method attribute specifies the
HTTP method to use when submitting the form data.

Here’s an example of processing output in JSP:

[Link] 6/7
11/28/24, 11:03 AM Unit-6: Java Server Pages – B.C.A study

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

pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Processing Output</title>
</head>
<body>
<%
String name = [Link]("name");
%>
<h1>Hello, <%= name %></h1>
</body>
</html>

In this example, the JSP page uses the request object to retrieve the value of the name parameter
submitted by the form. The value of the name variable is then inserted into the HTML using the JSP
expression <%= name %>. When the JSP is executed, the resulting HTML sent to the client’s web
browser will display a greeting with the user’s name.

You can also use the JSP Standard Tag Library (JSTL) to process input and output in a more
convenient way. For example, you can use the <c:out value="${...}" /> tag to output a value,
and the <c:set var="..." value="..." /> tag to set a variable. The JSTL also provides other tags
for URL manipulation, formatting, and internationalization


A [Link] Website.

[Link] 7/7