JAVA

UNIT 1
Overview of Java:
Characteristics of Java:
JVM, JRE, JDK
Parameters used in First Java Program
Basic Java Program Understanding
Java program Compilation and Execution Process
JVM as an interpreter and emulator
Instruction Set
class File Format
Security Promises of the JVM
Class loaders and security aspects
Sandbox model
UNIT 2
Java Fundamentals: Data Types, Literals, and Variables
Operators
Control of Flow
Classes and Instances
Inheritance
Throw and Throws clauses
User defined Exceptions
Applets
UNIT - 3
Threads
Runnable Interface
Thread Communication
AWT Components
Component Class and Container Class:
Layout Manager Interface and Default Layouts:
Insets and Dimensions:
Border Layout:
Flow Layout:
Card Layout:
Grid Bag Layout:
AWT Events:
Event Models:

JAVA 1
 Listeners:
Class Listener:
Adapters:
Action Event Methods:
Focus Event Methods:
Key Event Methods:
Mouse Events:
Window Events:
UNIT - 4
Input/Output Streams:
Stream Filters:
Data Input and Output Stream:
Print Stream:
Random Access File:
JDBC (Database connectivity with MS-Access, Oracle, MS-SQL Server)
Object Serialization
Sockets
Development of client Server applications
Design of multithreaded server
Remote Method invocation
Java Native interfaces and Development of a JNI based application
Java Collection API Interfaces

UNIT 1
Overview of Java:

Java is a widely-used programming language that was developed by Sun

Microsystems (now owned by Oracle) in the mid-1990s. It is known for its
platform independence, object-oriented programming (OOP) features, and
robustness. Java is used for building a variety of applications, including desktop
software, mobile apps, web applications, and enterprise systems.

Characteristics of Java:

JAVA 2
 1. Platform Independence: One of the key features of Java is its ability to run
on any platform that supports Java Virtual Machine (JVM). This platform
independence is achieved by compiling Java source code into bytecode,
which can be executed on any system with a compatible JVM.

2. Object-Oriented Programming (OOP): Java is designed around the

principles of object-oriented programming, which allows developers to model
real-world entities as objects and organize code into reusable and modular
components. Concepts like classes, objects, inheritance, and polymorphism
are integral to Java's OOP paradigm.

3. Simple and Readable Syntax: Java has a straightforward syntax that is easy
to learn and read. It borrows many syntax conventions from languages like
C and C++, making it familiar to programmers from those backgrounds. The
language promotes clean and organized code through its syntax rules.

4. Robustness and Memory Management: Java's robustness is achieved

through features like exception handling, automatic memory management
(garbage collection), and strong type checking. Exceptions help in dealing
with errors and exceptions that may occur during program execution, while
garbage collection relieves developers from manually managing memory
allocation and deallocation.

5. Rich Standard Library: Java comes with a vast standard library that provides
a wide range of pre-built classes and functions for common programming
tasks. This library includes utilities for input/output operations, data
structures, networking, multithreading, and more. Utilizing the standard
library saves development time and effort.

6. Security: Java emphasizes security and provides built-in mechanisms for

secure programming. It includes features like bytecode verification,
sandboxing, and security managers, which help in creating secure and
trusted applications.

7. Scalability and Performance: Java's scalability and performance have

improved over the years. The Just-In-Time (JIT) compiler optimizes
bytecode at runtime, translating it into machine code for efficient execution.
Additionally, Java supports multi-threading, enabling developers to write
concurrent and efficient programs.

JAVA 3
 8. Community and Ecosystem: Java has a large and active developer
community, which contributes to its rich ecosystem. There are numerous
frameworks, libraries, and tools available for Java development, making it
easier to build complex applications quickly.

Overall, Java is a powerful and versatile programming language known for its
platform independence, object-oriented approach, and robustness. It is widely
used in various domains and provides a solid foundation for building reliable and
scalable applications.

JVM, JRE, JDK

1. JVM: The JVM (Java Virtual Machine) is a crucial component of the Java
platform. It provides a runtime environment for executing Java bytecode.
The JVM interprets or compiles Java bytecode into machine code and
handles memory management, security, and other runtime functionalities. It
ensures that Java programs are platform-independent, as bytecode can be
executed on any system with a compatible JVM.

2. JRE: The JRE (Java Runtime Environment) is a software package that

includes the JVM, libraries, and other components necessary for running
Java applications. It is a subset of the Java Development Kit (JDK) and is
primarily used by end-users who only need to run Java programs, not
develop them.

3. JDK: The JDK (Java Development Kit) is a software development kit that
includes tools, libraries, and the JRE. It is used by developers to create,
compile, and debug Java applications. The JDK contains the necessary
components for both development and execution of Java programs.

Parameters used in First Java Program

Let's see what is the meaning of class, public, static, void, main, String[],
System.out.println().

class keyword is used to declare a class in Java.

JAVA 4
 public keyword is an access modifier that represents visibility. It means it is
visible to all.

static is a keyword. If we declare any method as static, it is known as the

static method. The core advantage of the static method is that there is no
need to create an object to invoke the static method. The main() method is
executed by the JVM, so it doesn't require creating an object to invoke the
main() method. So, it saves memory.

void is the return type of the method. It means it doesn't return any value.

main represents the starting point of the program.

String[] args or String args[] is used for command line argument. We will
discuss it in coming section.

System.out.println() is used to print statement. Here, System is a class, out

is an object of the PrintStream class, println() is a method of the PrintStream
class. We will discuss the internal working of System.out.println() statement
in the coming section.

Basic Java Program Understanding

// Importing necessary classes from Java standard library

import java.util.Scanner;

// Main class declaration

public class BasicJavaProgram {

// Main method, the entry point of the program

public static void main(String[] args) {
// Create a Scanner object to read input from the user
Scanner scanner = new Scanner(System.in);

// Prompt the user to enter their name

System.out.print("Enter your name: ");

// Read the input from the user

String name = scanner.nextLine();

// Print a welcome message with the entered name

System.out.println("Welcome, " + name + "!");

// Close the scanner

scanner.close();
}
}

JAVA 5
 Let's break down the different components of the program:

1. Import Statements:

The program begins with import statements that specify the classes from
the Java standard library that will be used in the program.

In this example, we import the Scanner class from the java.util package
to facilitate user input.

2. Public Class:

Next, we declare a public class called BasicJavaProgram .

The class name should match the filename (excluding the .java

extension) and follow Java naming conventions.

3. Main Method:

Inside the BasicJavaProgram class, we have the main method, which

serves as the entry point of the program.

The main method is declared as public , static , and void , with a single
parameter of type String array ( String[] args ).

public indicates that the method can be accessed from outside the
class.

static means the method belongs to the class itself, rather than an
instance of the class.

void specifies that the method does not return any value.

4. Method Body:

The method body is enclosed within curly braces {} .

Inside the main method, we create a Scanner object to read input from
the user.

5. User Input:

We prompt the user to enter their name using the System.out.print()

method, which displays the message without a newline character.

JAVA 6
 Then we use the Scanner object's nextLine() method to read the user's
input and store it in the name variable of type String .

6. Output:

We use the System.out.println() method to print a welcome message

along with the entered name.

The println() method adds a newline character after printing the

message.

7. Scanner Closing:

We close the Scanner object using the close() method to release

system resources.

This program demonstrates the basic structure of a Java program, including

import statements, class declaration, the main method, user input with Scanner ,
and output with System.out.println() . You can run this program to prompt the
user for their name and display a welcome message.

Java program Compilation and Execution Process

The compilation and execution process in Java involves several steps. Let's
break it down:

1. Writing Java Source Code:

To begin, you need to write your Java program's source code. This is
done in a plain text file with a .java extension. You can use any text
editor or integrated development environment (IDE) for this purpose.

2. Compiling Java Source Code:

The next step is to compile the Java source code into bytecode.
Bytecode is a platform-independent representation of your program that
can be executed by the Java Virtual Machine (JVM).

To compile the source code, you use the Java compiler (javac) that
comes with the Java Development Kit (JDK). In the command prompt or
terminal, navigate to the directory where your source code file is located
and execute the following command:

JAVA 7
 javac YourProgram.java

If there are no errors in your code, the compiler will generate a bytecode
file with a .class extension. This file contains the compiled version of
your program.

3. Java Virtual Machine (JVM):

The JVM is responsible for executing Java bytecode. It acts as an

interpreter for the bytecode and provides a runtime environment for your
program.

When you run a Java program, you need to have a JVM installed on
your machine. The JVM takes care of loading and executing the
bytecode.

4. Running Java Bytecode:

To run the compiled bytecode, you use the java command followed by
the name of the class containing the main method (the entry point of
your program).

In the command prompt or terminal, navigate to the directory where your

.class file is located and execute the following command:

java YourProgram

The JVM will start executing the bytecode, and your program will run
accordingly.

The Java Virtual Machine (JVM) is the cornerstone of the Java platform. It
provides a runtime environment for executing Java bytecode and plays a crucial
role in the platform's platform independence and security. Let's explore the
organization of the JVM:

1. Class Loader:

When a Java program is executed, the JVM's class loader subsystem is

responsible for loading classes into the memory. It performs tasks such

JAVA 8
 as locating and loading the necessary class files from the file system,
network, or other sources.

The class loader is divided into three main components: the bootstrap
class loader, extension class loader, and application class loader. These
loaders work together to load classes based on the class's visibility and
dependency requirements.

2. Runtime Data Areas:

The JVM defines several runtime data areas that are used during
program execution:

Method Area: The method area stores class-level structures such as

method bytecode, field information, constant pool, and static
variables.

Heap: The heap is a runtime data area where objects are allocated.
It is divided into different regions and is the memory area managed
by the garbage collector for dynamic memory allocation and
deallocation.

Java Stack: Each thread in the JVM has its own Java stack, which is
used for method execution and storing local variables, method
parameters, and partial results. It also keeps track of method
invocations and returns.

PC (Program Counter) Register: The PC register keeps track of the

currently executing JVM instruction. It holds the address of the next
bytecode instruction to be executed.

Native Method Stack: The native method stack is used for executing
native code (code written in languages other than Java) and
handling interactions with the underlying operating system.

3. Execution Engine:

The JVM's execution engine is responsible for executing the Java

bytecode. It consists of the following components:

Just-In-Time (JIT) Compiler: The JIT compiler dynamically compiles

frequently executed bytecode into native machine code for improved

JAVA 9
 performance. It optimizes the execution of the bytecode by
analyzing and translating it into efficient machine instructions.

Interpreter: The interpreter reads and executes bytecode

instructions one by one. It is responsible for executing less
frequently executed code and acts as a fallback when the JIT
compiler has not yet compiled certain bytecode.

4. Garbage Collector (GC):

Memory management is an essential aspect of the JVM. The garbage

collector automatically manages memory by reclaiming unused objects
and deallocating memory that is no longer needed.

The garbage collector identifies objects that are no longer reachable and
frees the memory occupied by them, ensuring efficient memory usage
and preventing memory leaks.

5. Native Method Interface (JNI):

The Native Method Interface (JNI) allows Java code to interact with code
written in other programming languages, such as C or C++. It provides a
way to call native methods and exchange data between Java and native
code.

6. Security Manager and Sandbox:

The JVM incorporates a security manager that enforces security policies

to protect the system and prevent unauthorized actions. It ensures that
Java code runs within a controlled environment called the sandbox,
which restricts potentially harmful operations.

The organization of the JVM provides a runtime environment that enables

platform independence, memory management, dynamic class loading, bytecode
execution, and security measures for Java applications.

JVM as an interpreter and emulator

The JVM (Java Virtual Machine) can be viewed as both an interpreter and an
emulator, depending on how it executes Java bytecode. Let's explore these
concepts:

JAVA 10
 1. JVM as an Interpreter:

The JVM interprets Java bytecode instructions one by one and executes
them. It reads the bytecode, understands the instruction, and performs
the corresponding operation. This interpretation happens at runtime.

When the JVM is in the interpreting mode, it executes the bytecode

without converting it into machine code. This allows for platform
independence, as the bytecode is designed to be executed on any
system with a compatible JVM.

The interpreter is responsible for executing less frequently executed

code or code segments that are not yet compiled by the Just-In-Time
(JIT) compiler.

2. JVM as an Emulator:

The JVM can also be considered an emulator in the sense that it

emulates a virtual computing environment in which the Java program
runs. It creates a virtual representation of the underlying hardware and
provides a runtime environment for executing Java programs.

The JVM abstracts the low-level hardware details and provides a

consistent platform for Java programs to run on. It emulates features like
memory management, stack management, thread management, and
input/output operations.

By providing this emulation layer, the JVM ensures that Java programs
can run consistently across different platforms without being directly
dependent on the underlying hardware and operating system.

It's important to note that the JVM combines interpretation and emulation with
the Just-In-Time (JIT) compilation technique to improve performance. The JIT
compiler dynamically compiles frequently executed bytecode into native machine
code, which can be directly executed by the CPU. This compilation process
optimizes the execution speed of the Java program by eliminating the
interpretation overhead.
So, while the JVM primarily operates as an interpreter, it also incorporates
emulation techniques to provide a consistent runtime environment and platform
independence for Java programs.

JAVA 11
 Instruction Set
The instruction set in the context of Java refers to the set of bytecode
instructions that the Java Virtual Machine (JVM) can execute. These instructions
are specified by the Java Virtual Machine Specification and are used to perform
various operations and control flow within a Java program.

Here are some common bytecode instructions found in the Java instruction set:

1. Load and Store Instructions:

iload , fload , aload : Load an integer, float, or reference from a local

variable onto the stack.

istore , fstore , astore : Store an integer, float, or reference from the

stack into a local variable.

2. Arithmetic and Logical Instructions:

iadd , fadd : Add two integers or floats.

isub , fsub : Subtract two integers or floats.

imul , fmul : Multiply two integers or floats.

idiv , fdiv : Divide two integers or floats.

irem , frem : Compute the remainder of two integers or floats.

iand , ior , ixor : Perform bitwise AND, OR, XOR on two integers.

ishl , ishr , iushr : Perform shift operations on integers.

3. Control Flow Instructions:

if<cond> <label> : Perform a conditional jump to the specified label based

on a condition (e.g., ifeq , ifne , iflt ).

goto <label> : Unconditionally jump to the specified label.

tableswitch , lookupswitch : Perform a switch statement based on a table

or lookup.

4. Object-oriented Instructions:

new : Create a new instance of a class.

getfield , putfield : Get or set the value of a field in an object.

JAVA 12
 invokevirtual , invokestatic , invokeinterface : Invoke methods on objects
or classes.

5. Array Instructions:

newarray , anewarray : Create a new array of primitive types or objects.

arraylength : Get the length of an array.

iaload , faload , aaload : Load an element from an array onto the stack.

iastore , fastore , aastore : Store an element from the stack into an

array.

These are just a few examples of the instructions available in the Java bytecode
instruction set. The JVM executes these instructions in a stack-based manner,
where operands are pushed onto a stack and operations are performed on the
top elements of the stack.

It's worth noting that Java bytecode instructions are designed to be platform-
independent and are executed by the JVM, which is responsible for translating
them into machine code specific to the underlying hardware architecture.

class File Format

The class file format is a binary file format used by the Java Virtual Machine
(JVM) to represent compiled Java bytecode. It defines the structure and
organization of the data stored in a class file. Here's an overview of the class file
format:

1. Magic Number and Version:

The class file starts with a fixed 4-byte magic number ( 0xCAFEBABE ) that
identifies it as a valid class file.

The version numbers (minor and major) indicate the version of the class
file format being used.

2. Constant Pool:

The constant pool section stores various constant values used by the
class, such as strings, class names, field names, method names, and
more.

JAVA 13
 The constant pool is an array-like structure, and each entry has a tag
indicating its type and the actual value.

3. Access Flags and Class Information:

The access flags represent the access level and properties of the class
(e.g., public, final, abstract).

The class information includes the fully qualified name of the class, the
name of its superclass, and interfaces it implements.

4. Fields and Methods:

The fields section lists the fields (variables) defined within the class,
along with their access flags, names, types, and any initial values.

The methods section contains information about the methods defined in

the class, including access flags, names, return types, parameter types,
and bytecode instructions.

5. Attributes:

Attributes provide additional metadata about the class, fields, and

methods.

They can include information such as source file name, line number
tables, exceptions thrown, annotations, and more.

The class file format follows a specific structure and is designed to be platform-
independent. It allows the JVM to interpret and execute the bytecode on any
system that has a compatible JVM implementation.

It's important to note that the class file format is defined in the Java Virtual
Machine Specification and is subject to updates and revisions as new versions
of the JVM are released.

Verification is an important process performed by the JVM to ensure the

integrity and safety of Java bytecode before it is executed. The verification
process checks the bytecode for various security and structural constraints to
prevent potentially malicious or erroneous code from being executed. Here are
some key aspects of bytecode verification

JAVA 14
 1. Bytecode Structure: The verification process ensures that the bytecode
conforms to the structural rules defined by the JVM specification. It checks
for valid instructions, correct operand types, proper control flow, and
exception handling.

2. Type Safety: Verification verifies the type safety of the bytecode by

examining the data types used in the bytecode instructions. It ensures that
operations are performed on appropriate data types and that type
conversions are valid.

3. Memory Safety: Verification checks for memory safety, preventing illegal

memory accesses or operations that could lead to memory corruption or
security vulnerabilities.

4. Stack Integrity: The verification process ensures that the bytecode's stack
operations, such as pushing and popping values, are well-formed and don't
violate the stack's integrity.

By performing bytecode verification, the JVM reduces the risk of executing

untrusted or faulty code, providing a level of security and stability to Java
programs.
Class Area (Method Area):
The Class Area, also known as the Method Area, is a runtime data area within
the JVM where class-level structures and metadata are stored. It is shared
among all threads and is created when the JVM starts up. Here are some key
features of the Class Area:

1. Class Structures: The Class Area stores information about classes and
interfaces loaded by the JVM. This includes the fully qualified names of the
classes, superclass and interface references, field information, method
bytecode, constant pool, and static variables.

2. Runtime Constant Pool: The Class Area contains a runtime representation

of the constant pool, which is a table of symbolic references used by the
class. It stores strings, numeric constants, class and method references, and
more.

3. Method Bytecode: The Class Area holds the bytecode instructions for
methods defined in the loaded classes. These instructions are interpreted or
compiled to machine code for execution.

JAVA 15
 4. Static Variables: The Class Area also includes memory space for static
variables, which are shared among all instances of a class. Static variables
are initialized when the class is loaded and can be accessed without
creating an instance of the class.

The Class Area provides a centralized location for class-level information and
allows efficient sharing of data among multiple instances of the same class. It is
managed by the JVM's garbage collector, which handles the allocation and
deallocation of memory within the Class Area.

Java Stack:
The Java Stack is a region of memory used for method execution and storing
local variables and method call information. Here are some key points about the
Java Stack:

1. Stack Frames: Each method invocation creates a new stack frame, also
known as an activation record, on the Java Stack. The stack frame contains
information such as local variables, method parameters, return address, and
intermediate results.

2. Last-In-First-Out (LIFO): The Java Stack follows the Last-In-First-Out

principle, meaning that the most recently pushed item onto the stack is the
first to be popped off when a method call completes.

3. Memory Management: The Java Stack is managed automatically by the

JVM. Memory for stack frames is allocated and deallocated as method calls
are made and completed. The stack memory is typically smaller in size
compared to the heap memory.

4. Thread-Specific: Each thread in a Java program has its own stack. This
allows multiple threads to execute methods concurrently without interfering
with each other's stack frames.

The Java Stack is efficient for managing method calls and local variables
because of its simple and predictable nature. However, it has limited memory
compared to the Java Heap.

Java Heap:
The Java Heap is a region of memory used for dynamic memory allocation,

JAVA 16
 specifically for objects and arrays. Here are some key points about the Java
Heap:

1. Object Storage: The Java Heap is where objects are allocated and
deallocated during the program's execution. Objects are created using the
"new" keyword and reside in the heap until they are no longer referenced.

2. Dynamic Memory: The Java Heap provides dynamic memory allocation,

meaning that objects can be created and destroyed at runtime. This allows
for flexibility in managing memory resources.

3. Garbage Collection: The Java Heap is managed by the JVM's garbage

collector. The garbage collector automatically identifies and reclaims
memory occupied by objects that are no longer referenced, freeing up
memory for future allocations.

4. Shared Among Threads: Unlike the Java Stack, the Java Heap is shared
among all threads in a Java program. Multiple threads can access and
modify objects stored in the heap simultaneously.

Garbage Collection:
Garbage Collection is the process of automatically reclaiming memory occupied
by objects that are no longer needed in a Java program. Here are some key
points about Garbage Collection:

1. Object Lifetimes: Garbage Collection identifies objects that are no longer

reachable or referenced by any part of the program. These objects are
considered garbage and eligible for collection.

2. Mark and Sweep: The most common garbage collection algorithm is the
Mark and Sweep algorithm. It works by traversing objects starting from the
root references (e.g., static variables, method call stacks) and marking
reachable objects. Unmarked objects are then swept and their memory is
reclaimed.

3. Stop-The-World: Garbage Collection typically involves a "stop-the-world"

event where normal program execution is temporarily paused while garbage
collection takes place. During this time, the JVM examines and collects
garbage objects, and other threads are halted.

4. Generational Collection: Many modern JVMs use generational garbage

collection, where the heap is divided into different generations (young, old)

JAVA 17
 based on object lifetimes. This allows for more efficient garbage collection by
focusing on short-lived objects in the young generation.

Garbage Collection automates memory management, relieving developers from

manual memory deallocation. It helps prevent memory leaks and ensures
efficient memory utilization.

Security Promises of the JVM

The Java Virtual Machine (JVM) provides several security features and promises
that help ensure the safety and security of Java applications. Here are some key
security promises of the JVM:

Every object is constructed exactly once before it is used.

Every object is an instance of exactly one class, which does not change
through the life of the object.

If a field or method is marked private, then the only code that ever accesses
it is found within the class itself.

Fields and methods marked protected are used only by code that
participates in the implementation of the class.

Every local variable is initialized before it is used.

Every field is initialized before it is used.

It is impossible to underflow or overflow the stack.

It is impossible to read or write past the end of an array or before the

beginning of the array.

It is impossible to change the length of an array once it has been created.

Final methods cannot be overridden, and final classes cannot be

subclassed.

Attempts to use a null reference as the receiver of a method invocation or

source of a field cause a NullPointerException to be thrown.

Security Architecture:
The security architecture of the JVM encompasses the design principles,
mechanisms, and features that ensure the security of Java applications. It

JAVA 18
 provides a layered approach to protect the integrity, confidentiality, and
availability of resources within the JVM. Here are key aspects of the JVM's
security architecture:

1. Security Manager: The Security Manager is a component of the JVM's

security architecture that enforces security policies and permissions for Java
applications. It defines the boundaries and restrictions within which an
application can execute. The Security Manager grants or denies permissions
based on the policies defined in the security policy file.

2. Security Providers: The JVM allows the integration of security providers that
offer cryptographic algorithms, secure protocols, and other security-related
services. These providers implement the Java Cryptography Architecture
(JCA) and Java Cryptography Extension (JCE) to provide cryptographic
functionalities such as encryption, digital signatures, and secure random
number generation.

3. Access Control: The JVM's security architecture incorporates access control

mechanisms to regulate access to system resources and sensitive
operations. It enforces restrictions on file system access, network
communication, reflection, and other potentially dangerous actions, ensuring
that only authorized code can perform them.

4. Class Loading and Sandboxing: The JVM's class loading mechanism and
sandboxing model contribute to its security architecture. Class loading
ensures that classes are loaded from trusted sources and verified before
execution. The sandboxing model restricts untrusted code by isolating its
execution environment, preventing unauthorized access to resources and
system operations.

5. Secure Communication: The JVM supports secure communication protocols

and APIs, such as HTTPS, SSL/TLS, and cryptographic libraries. These
enable secure client-server communication, data encryption, and
authentication to protect sensitive information during transmission.

Security Policy:
The security policy in the JVM defines the permissions and access controls for
Java applications. It specifies the rules and restrictions that determine what
operations an application can perform and what resources it can access. The

JAVA 19
 security policy is typically defined in a security policy file, which is loaded by the
JVM during application startup.

Class loaders and security aspects

Class loaders in Java play a crucial role in loading and initializing classes at
runtime. They also have implications for the security of Java applications. Let's
explore the relationship between class loaders and security aspects:

1. Class Loading Hierarchy:

Class loaders in Java follow a hierarchical structure. Each class loader

has a parent class loader, except for the bootstrap class loader, which is
the root of the hierarchy.

When a class needs to be loaded, the class loader first delegates the
task to its parent. If the parent class loader cannot find the class, the
current class loader attempts to load it.

2. Class Loading Isolation:

Class loaders provide a mechanism for class loading isolation. Each

class loader has its own namespace, meaning that classes loaded by
different class loaders are treated as distinct types, even if they have the
same fully qualified name.

This isolation helps maintain security boundaries between different

components or modules of an application.

3. Security Constraints:

Class loaders play a role in enforcing security constraints by managing

the loading and access of classes and resources.

The Java Security Manager, along with the security policy, defines the
permissions and restrictions for different code sources. Class loaders
are responsible for implementing these security policies by loading
classes in accordance with the defined constraints.

4. Security Manager and Class Loaders:

JAVA 20
 The Security Manager, as part of the JVM's security architecture,
interacts with class loaders to enforce security policies and permissions.

When a class is loaded, the Security Manager is consulted to determine

whether the class is granted the necessary permissions to perform
certain operations or access specific resources.

Class loaders assist in this process by ensuring that classes and code
sources adhere to the security policies defined by the Security Manager.

5. Custom Class Loaders:

Java allows the creation of custom class loaders that can be used to
extend or modify the default class loading behavior.

Custom class loaders can introduce additional security measures. For

example, they can implement bytecode verification or perform extra
security checks before loading classes from untrusted sources.

By controlling the loading and initialization of classes, class loaders contribute to

the security of Java applications. They provide isolation, enable the enforcement
of security policies, and allow for customizations to enhance security measures.
It's important to note that proper configuration and implementation of class
loaders, along with adherence to secure coding practices, are essential for
maintaining a secure runtime environment.

Sandbox model
The sandbox model is a security mechanism implemented in the Java Virtual
Machine (JVM) to restrict untrusted code from accessing sensitive resources
and performing potentially harmful operations. It creates a controlled execution
environment for untrusted code, ensuring that it operates within predefined
boundaries. Here are the key aspects of the sandbox model:

1. Isolation: The sandbox model achieves isolation by restricting the

capabilities of untrusted code and preventing it from accessing certain
resources or performing privileged operations. This isolation ensures that
the untrusted code cannot interfere with or compromise the integrity of the
underlying system or other applications.

JAVA 21
 2. Access Control: The sandbox model enforces access control policies to
regulate the interactions between the untrusted code and the system
resources. It specifies what resources the code can access, such as the file
system, network, or system properties. By controlling these access rights,
the sandbox model limits the potential damage that untrusted code can
cause.

3. Security Manager: The Security Manager, a component of the JVM's

security architecture, plays a central role in implementing the sandbox
model. It acts as a gatekeeper, enforcing the security policies and
permissions defined for the untrusted code. The Security Manager checks
each operation performed by the code against the defined security policies
and determines whether it is allowed or denied.

4. Security Policies: The security policies in the sandbox model define the
permissions and restrictions for untrusted code. These policies are typically
specified in a security policy file, which is loaded by the JVM. The policies
can specify the allowable actions, such as reading or writing files, creating
network connections, or accessing certain system properties. The Security
Manager uses these policies to determine whether the requested actions are
permitted.

5. Code Verification: To ensure the safety of the sandboxed environment,

untrusted code undergoes bytecode verification before execution. Bytecode
verification checks the code for adherence to specified rules and constraints,
including type safety, proper stack manipulation, and method invocations.
This verification step helps prevent the execution of potentially malicious or
malformed code.

6. Limited Permissions: The sandbox model grants only limited permissions to

untrusted code. It typically allows access to a restricted subset of the Java
API, preventing the code from invoking sensitive operations or accessing
critical system resources. This limitation helps contain any potential damage
caused by the code and prevents unauthorized access to sensitive
information.

7. Controlled Execution Environment: The sandbox model ensures that

untrusted code runs in a controlled execution environment. It sets up
boundaries that prevent the code from modifying system configurations,

JAVA 22
 accessing protected resources, or executing native code. By confining the
code within the sandbox, the model provides a layer of protection against
malicious actions.

The sandbox model is particularly useful when executing untrusted code, such
as applets in web browsers or code from unknown sources. It allows for the
execution of potentially risky code while mitigating the risks and maintaining the
overall security of the system.

It's worth noting that the effectiveness of the sandbox model relies on proper
configuration, adherence to security best practices, and regular updates to
address potential vulnerabilities in the JVM.

UNIT 2
Java Fundamentals: Data Types, Literals, and Variables
Java is a statically-typed programming language, which means that you need to
declare the type of a variable before using it. Java provides several built-in data
types to store different kinds of values. Let's explore the fundamentals of data
types, literals, and variables in Java:

Data Types:
Java has two categories of data types: primitive types and reference types.

1. Primitive Types:

boolean: Represents true or false values.

byte: Stores a signed 8-bit integer.

short: Stores a signed 16-bit integer.

int: Stores a signed 32-bit integer.

long: Stores a signed 64-bit integer.

float: Stores a 32-bit floating-point number.

double: Stores a 64-bit floating-point number.

char: Stores a single Unicode character.

JAVA 23
 2. Reference Types:

Classes: Objects of user-defined classes.

Arrays: Ordered collections of elements.

Interfaces: Reference types that define a contract for classes

implementing them.

Strings: Represents sequences of characters.

Literals:
Literals are constant values that are directly written into your code. They
represent specific values of different data types.
For example:

Numeric literals: 10, 3.14, -5

Boolean literals: true, false

Character literals: 'A', '\n', '\u0065'

String literals: "Hello, World!"

Variables:
Variables are named memory locations used to store data. Before using a
variable, you must declare it with its data type. Here's the syntax to declare a
variable:

dataType variableName;

For example:

int age;
double salary;
boolean isStudent;

You can also assign an initial value to a variable during declaration:

dataType variableName = initialValue;

JAVA 24
 For example:

int age = 25;

double salary = 5000.0;
boolean isStudent = true;

Once a variable is declared, you can assign new values to it using the
assignment operator (=):

variableName = newValue;

For example:

age = 30;
salary = 5500.0;
isStudent = false;

Java supports type inference with the introduction of the var keyword in Java
10. It allows the compiler to infer the data type based on the assigned value.

For example:

var name = "John"; // The variable type is inferred as String.

var count = 10; // The variable type is inferred as int.

Variables can be used in expressions and can be reassigned with new values
throughout the program.

Remember to follow the naming conventions for variables, such as starting with
a lowercase letter and using camel case (e.g., myVariable).

Understanding data types, literals, and variables is crucial for writing Java
programs. It enables you to store and manipulate different kinds of data in your
applications.

Wrapper Classes:
In Java, wrapper classes are used to represent the primitive data types as

JAVA 25
 objects. They provide a way to encapsulate primitive values and provide
additional functionality through methods defined in the wrapper class. The
wrapper classes are part of the java.lang package and include the following:

1. Boolean: Represents the boolean primitive type.

2. Byte: Represents the byte primitive type.

3. Short: Represents the short primitive type.

4. Integer: Represents the int primitive type.

5. Long: Represents the long primitive type.

6. Float: Represents the float primitive type.

7. Double: Represents the double primitive type.

8. Character: Represents the char primitive type.

Wrapper classes are commonly used when you need to perform operations such
as converting a primitive type to a string, parsing a string to a primitive type, or
using collections that require objects rather than primitives.
For example, to convert an int to a String, you can use the Integer wrapper
class:

int number = 10;

String strNumber = Integer.toString(number);

Arrays:
Arrays in Java are used to store multiple elements of the same type. They
provide a way to work with collections of values in a structured manner. Here are
some key points about arrays in Java:

1. Declaration and Initialization:

Arrays are declared using square brackets ([]).

You specify the data type followed by the variable name and square
brackets indicating the array dimensions.

Arrays can be initialized during declaration or later.

JAVA 26
 // Declaration and initialization
int[] numbers = {1, 2, 3, 4, 5};

// Declaration and later initialization

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

1. Accessing Array Elements:

Array elements are accessed using their index, starting from 0.

You can retrieve or modify the value at a specific index using the array
variable and the index in square brackets.

int thirdNumber = numbers[2]; // Accessing the third element

numbers[0] = 10; // Modifying the first element

1. Array Length:

The length of an array is determined by the number of elements it can

hold.

The length of an array can be obtained using the length property.

int arrayLength = numbers.length; // Retrieves the length of the array

1. Multidimensional Arrays:

Java supports multidimensional arrays, such as 2D arrays or arrays with

more dimensions.

To declare and initialize a 2D array:

int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

1. Arrays and Enhanced for Loop:

The enhanced for loop (for-each loop) allows iterating over the elements
of an array without explicitly using the index.

JAVA 27
 for (int number : numbers) {
System.out.println(number);
}

Arrays provide a convenient way to work with collections of values in Java. They
allow efficient storage and retrieval of data and are extensively used in various
programming scenarios.

Operators
1. Arithmetic Operators:

Addition (+): Adds two operands.

int sum = 5 + 3; // sum is 8

Subtraction (-): Subtracts the second operand from the first.

int difference = 7 - 2; // difference is 5

Multiplication (*): Multiplies two operands.

int product = 4 * 6; // product is 24

Division (/): Divides the first operand by the second.

int quotient = 10 / 3; // quotient is 3

Modulus (%): Returns the remainder of the division.

int remainder = 10 % 3; // remainder is 1

Increment (++) and Decrement (--): Increases or decreases the value of

an operand by 1.

JAVA 28
 int count = 5;
count++; // count is now 6
count--; // count is now 5

2. Assignment Operators:

Assignment (=): Assigns the value of the right operand to the left
operand.

int number = 10;

Compound Assignment Operators (e.g., +=, -=, *=, /=): Performs the
operation and assigns the result to the left operand.

int value = 5;
value += 3; // value is now 8

3. Comparison Operators:

Equality (==): Tests if two operands are equal.

boolean isEqual = (10 == 5); // isEqual is false

Inequality (!=): Tests if two operands are not equal.

boolean notEqual = (10 != 5); // notEqual is true

Greater than (>), Less than (<), Greater than or equal to (>=), Less than
or equal to (<=): Compare the values of two operands.

boolean greaterThan = (10 > 5); // greaterThan is true

4. Logical Operators:

Logical AND (&&): Returns true if both operands are true.

JAVA 29
 boolean result = (true && false); // result is false

Logical OR (||): Returns true if either operand is true.

boolean result = (true || false); // result is true

Logical NOT (!): Negates the value of an operand.

boolean result = !true; // result is false

5. Bitwise Operators: (Note: Examples below use integer values)

Bitwise AND (&): Performs a bitwise AND operation.

int result = 5 & 3; // result is 1

Bitwise OR (|): Performs a bitwise OR operation.

int result = 5 | 3; // result is 7

Bitwise XOR (^): Performs a bitwise XOR (exclusive OR) operation.

int result = 5 ^ 3; // result is 6

Bitwise NOT (~): Inverts the bits of the operand.

int result = ~5; // result is -6

Left Shift (<<): Shifts the bits of the left operand to the left by a specified
number of positions.

int result = 5 << 2; // result is 20

JAVA 30
 Right Shift (>>): Shifts the bits of the left operand to the right by a specified
number of positions.

int result = 20 >> 2; // result is 5

1. Conditional (Ternary) Operator:

Conditional Operator (condition ? expression1 : expression2): Evaluates

a condition and returns one of two expressions based on the result of
the condition.

int number = 10;

String result = (number > 5) ? "Greater than 5" : "Less than or equal to
5";

These are the main categories of operators in Java with corresponding

examples. Each operator serves a specific purpose and can be used to perform
various operations within your Java programs.

Control of Flow
Control Flow in Java refers to the order in which statements are executed in a
program. It allows you to make decisions, repeat statements, and break the
normal flow of execution. There are several constructs in Java that help you
control the flow of your program. Here are the main control flow constructs:

1. Conditional Statements:

If statement: Executes a block of code if a given condition is true.

if (condition) {
// code to be executed if the condition is true
} else {
// code to be executed if the condition is false
}

Switch statement: Allows you to select one of many code blocks to be

executed based on the value of an expression.

JAVA 31
 switch (expression) {
case value1:
// code to be executed if expression matches value1
break;
case value2:
// code to be executed if expression matches value2
break;
default:
// code to be executed if expression doesn't match any case
}

2. Looping Statements:

For loop: Repeats a block of code a specific number of times.

for (initialization; condition; iteration) {

// code to be executed in each iteration
}

While loop: Repeats a block of code as long as a given condition is true.

while (condition) {
// code to be executed as long as the condition is true
}

Do-while loop: Similar to the while loop, but the condition is evaluated
after executing the block of code, so it always executes at least once.

do {
// code to be executed
} while (condition);

Enhanced for loop (foreach loop): Iterates over elements of an array or a

collection.

for (type element : array/collection) {

// code to be executed for each element
}

3. Jump Statements:

JAVA 32
 Break statement: Terminates the execution of a loop or switch statement
and transfers control to the next statement after the loop or switch.

break;

Continue statement: Skips the remaining code within a loop and moves
to the next iteration.

continue;

Return statement: Exits from a method and optionally returns a value.

return value;

4. Branching Statements:

If-else if-else ladder: Allows you to check multiple conditions and

execute different blocks of code based on the first matching condition.

if (condition1) {
// code to be executed if condition1 is true
} else if (condition2) {
// code to be executed if condition2 is true
} else {
// code to be executed if none of the conditions are true
}

Ternary operator: Provides a shorthand way of writing if-else statements.

variable = (condition) ? expression1 : expression2;

These control flow constructs give you the ability to make decisions, repeat
code, and alter the flow of execution in your Java programs. By using these
constructs effectively, you can create programs that perform different actions
based on various conditions and iterate over data structures efficiently.

JAVA 33
 Classes and Instances
In Java, classes and instances are fundamental concepts of object-oriented
programming. Let's understand what they mean:

1. Classes:

A class is a blueprint or template that defines the structure and behavior

of objects.

It serves as a blueprint for creating multiple instances (objects) of the

same type.

A class encapsulates data (attributes/fields) and behavior (methods)

related to a specific concept or entity.

It provides the definition of how objects of that class should behave and
interact with each other.

Classes are declared using the class keyword followed by the class
name.

Here's an example of a simple class named Person :

public class Person {

// fields
String name;
int age;

// methods
void sayHello() {
System.out.println("Hello, my name is " + name);
}
}

2. Instances (Objects):

An instance (or object) is a concrete representation of a class.

It is created from a class using the new keyword, and each instance has
its own set of attributes (instance variables) and can perform actions
(invoke methods) defined in the class.

Multiple instances of the same class can exist, each with its own state
(values of attributes).

JAVA 34
 Instances are created dynamically at runtime when the program needs
them.

Here's an example of creating instances of the Person class:

// Creating instances of the Person class

Person person1 = new Person();
Person person2 = new Person();

// Accessing and modifying instance variables

person1.name = "John";
person1.age = 25;

person2.name = "Jane";
person2.age = 30;

// Invoking methods on instances

person1.sayHello(); // Output: Hello, my name is John
person2.sayHello(); // Output: Hello, my name is Jane

Each instance has its own set of instance variables, and changes made
to one instance do not affect other instances.

By defining classes and creating instances, you can model and represent real-
world entities or concepts in your Java programs. Classes provide the structure,
and instances allow you to work with individual objects based on that structure.

1. Class Member Modifiers:

Class member modifiers are keywords used to specify the accessibility

and behavior of class members (fields, methods, nested classes, and
constructors).

Some commonly used modifiers include:

public : The member can be accessed from any other class.

private : The member can only be accessed within the same class.

protected: The member can be accessed within the same class,

subclasses, and same package.

static : The member belongs to the class itself rather than an

instance of the class.

JAVA 35
 final : The member's value cannot be changed.

abstract : The member does not have an implementation and must

be overridden in subclasses.

Modifiers can be used in various combinations to define the desired

access and behavior of class members.

2. Anonymous Inner Class:

An anonymous inner class is a class without a name that is declared

and instantiated at the same time.

It is typically used when you need to create a class that implements an

interface or extends a class in a concise manner.

Anonymous inner classes are often used for event handling or defining
small, one-time-use classes.

Here's an example of creating an anonymous inner class that

implements an interface:

Runnable runnable = new Runnable() {

public void run() {
// implementation of the run() method
}
};

In the example above, an anonymous inner class is created that

implements the Runnable interface and provides an implementation for
the run() method.

3. Interfaces:

An interface in Java defines a contract or a set of methods that a class

must implement.

It is a collection of abstract methods, constants, and default methods

(methods with a default implementation).

Interfaces are used to achieve abstraction and provide a way to define

common behavior that can be implemented by multiple classes.

JAVA 36
 A class implements an interface using the implements keyword and
provides implementations for all the methods declared in the interface.

Here's an example of an interface and its implementation:

interface Shape {
void draw(); // Abstract method declaration
}

class Circle implements Shape {

public void draw() {
// Implementation of the draw() method for Circle
}
}

In the example above, the Shape interface declares an abstract method

draw() , and the Circle class implements that interface by providing an
implementation for the draw() method.

4. Abstract Classes:

An abstract class is a class that cannot be instantiated and is meant to

be subclassed.

It can contain abstract methods (methods without an implementation)

and may also have concrete methods.

Abstract classes provide a way to define common behavior and enforce

certain methods to be implemented by subclasses.

To declare an abstract class, use the abstract keyword.

Here's an example of an abstract class and its subclass:

abstract class Animal {

abstract void sound(); // Abstract method declaration
}

class Cat extends Animal {

void sound() {
// Implementation of the sound() method for Cat
}
}

JAVA 37
 In the example above, the Animal class is declared as abstract with an
abstract method sound() . The Cat class extends the Animal class and
provides an implementation for the sound() method.

These concepts - class member modifiers, anonymous inner classes, interfaces,

and abstract classes - are important elements in Java that allow you to define
and structure your code effectively. They provide flexibility, reusability, and
abstraction in your

Inheritance
Inheritance is a fundamental concept in object-oriented programming that allows
you to create new classes based on existing classes. It enables code reuse and
the establishment of hierarchical relationships between classes. Inheritance is
achieved through the process of deriving new classes from existing classes,
where the new classes inherit the properties and behavior of the existing
classes. Let's delve into the details of inheritance:

1. Superclass and Subclass:

Inheritance involves two main classes: the superclass (also known as

the base class or parent class) and the subclass (also known as the
derived class or child class).

The superclass is the existing class from which the subclass is derived.

The subclass inherits all the non-private fields and methods from the
superclass and can add its own unique fields and methods.

The subclass can also override or extend the functionality of the

superclass methods.

2. Inheritance Syntax:

To establish an inheritance relationship, the extends keyword is used in

Java.

The subclass is declared with the extends keyword followed by the

name of the superclass.

Here's an example:

JAVA 38
 class Superclass {
// superclass members
}

class Subclass extends Superclass {

// subclass members
}

3. Inherited Members:

The subclass inherits the non-private members (fields and methods) of

the superclass, including their access modifiers.

Inherited members are accessible in the subclass as if they were

defined in the subclass itself.

The subclass can directly use the inherited members without redefining
them, unless they are overridden.

4. Overriding Methods:

Overriding allows the subclass to provide its own implementation for a

method that is already defined in the superclass.

To override a method, the method in the subclass must have the same
signature (name, return type, and parameters) as the method in the
superclass.

The @Override annotation can be used to indicate that a method is

intended to override a superclass method (optional but recommended).

Here's an example of method overriding:

class Superclass {
void display() {
System.out.println("Superclass method");
}
}

class Subclass extends Superclass {

@Override
void display() {
System.out.println("Subclass method");
}
}

JAVA 39
 5. Access Modifiers in Inheritance:

The access modifiers ( public , private , protected , and default) play a

role in controlling the visibility of inherited members in the subclass.

In general, inherited fields and methods with public or protected access

modifiers are accessible in the subclass.

Private members are not inherited and cannot be accessed directly in

the subclass.

Default access (no access modifier specified) allows inherited members

to be accessed within the same package but not from subclasses in
different packages.

6. Inheritance Hierarchies:

Inheritance can form hierarchical relationships where multiple levels of

inheritance exist.

A subclass can become a superclass for another subclass, creating a

hierarchy of classes.

The subclass inherits both the members of its immediate superclass and
all the members of the superclass hierarchy above it.

Inheritance is a powerful mechanism in Java that facilitates code reuse,

promotes code organization, and supports the concept of specialization and
generalization. It allows you to create class hierarchies and build relationships
between classes, promoting modularity and extensibility in your code.

In Java, there are several types of inheritance that you can use to establish
relationships between classes. These types include:

1. Single Inheritance:

Single inheritance involves one class inheriting the properties and

behavior of a single superclass.

Each class can have only one direct superclass.

It forms a linear hierarchy of classes.

Example:

JAVA 40
 class Superclass {
// superclass members
}

class Subclass extends Superclass {

// subclass members
}

2. Multiple Inheritance (not supported in Java):

Multiple inheritance involves one class inheriting properties and behavior

from multiple superclasses.

In Java, direct multiple inheritance is not supported for classes, although

it is supported for interfaces.

This is done to avoid ambiguity and complexities that can arise from
multiple inheritance.

However, a class can implement multiple interfaces, which allows it to

inherit multiple contracts.

Example:

interface Interface1 {
// interface1 members
}

interface Interface2 {
// interface2 members
}

class MyClass implements Interface1, Interface2 {

// class members
}

3. Multilevel Inheritance:

Multilevel inheritance involves a series of classes being derived from

one another, forming a hierarchy.

Each class serves as the superclass for the next class in the hierarchy.

Example:

JAVA 41
 class Superclass {
// superclass members
}

class IntermediateClass extends Superclass {

// intermediate class members
}

class Subclass extends IntermediateClass {

// subclass members
}

4. Hierarchical Inheritance:

Hierarchical inheritance involves multiple subclasses inheriting from a

single superclass.

Each subclass shares the properties and behavior of the superclass and
can add its own unique features.

Example:

class Superclass {
// superclass members
}

class Subclass1 extends Superclass {

// subclass1 members
}

class Subclass2 extends Superclass {

// subclass2 members
}

5. Hybrid Inheritance (combination of multiple types):

Hybrid inheritance combines multiple types of inheritance, such as

single inheritance, multiple inheritance (via interfaces), multilevel
inheritance, and hierarchical inheritance.

It involves complex class hierarchies with different types of relationships.

Example:

JAVA 42
 class Superclass {
// superclass members
}

interface Interface1 {
// interface1 members
}

interface Interface2 {
// interface2 members
}

class Subclass extends Superclass implements Interface1, Interface2 {

// subclass members
}

It's important to note that Java does not support direct multiple inheritance for
classes, but it allows for implementing multiple interfaces, achieving a similar
effect. The choice of inheritance type depends on the specific requirements and
design of your program.

Throw and Throws clauses

In Java, the throw and throws clauses are used to handle and propagate
exceptions in a program. They play a crucial role in exception handling. Let's
understand these clauses in detail:

1. throw Clause:

The throw clause is used to explicitly throw an exception from a method

or a block of code.

It is followed by the exception instance or an expression that evaluates

to an exception.

When a throw statement is encountered, the normal flow of execution is

disrupted, and the specified exception is thrown.

The thrown exception is then propagated up the call stack until it is

caught and handled by an appropriate exception handler.

Syntax:

JAVA 43
 throw exception;

Example:

void divide(int dividend, int divisor) {

if (divisor == 0) {
throw new ArithmeticException("Division by zero");
}
// Perform the division operation
}

2. throws Clause:

The throws clause is used in the method declaration to indicate that the
method may throw one or more types of exceptions.

It specifies the types of exceptions that can be thrown by the method,

but it doesn't actually throw the exceptions itself.

It is followed by the list of exception types separated by commas.

When a method with a throws clause calls another method that throws a
checked exception, the calling method must handle or declare the
exception using its own throws clause.

Syntax:

returnType methodName(parameters) throws exceptionType1, exceptionType2,

... {
// Method body
}

Example:

void readFile(String filename) throws IOException {

// Code that may throw an IOException
}

In the example above, the readFile method declares that it may throw
an IOException . Any method calling readFile must either handle the

JAVA 44
 IOException or declare it in its own throws clause.

The throw clause is used to raise exceptions explicitly, while the throws clause
is used to declare the exceptions that a method can throw. Together, they
facilitate exception handling and ensure that exceptions are appropriately caught
and handled in the program.

It's worth noting that checked exceptions (exceptions that are subclasses of
Exception but not subclasses of RuntimeException ) must be declared using the
throws clause or caught using a try-catch block, whereas unchecked exceptions
(subclasses of RuntimeException ) do not need to be declared or caught.

User defined Exceptions

In Java, you can define your own exceptions by creating custom exception
classes. User-defined exceptions allow you to handle specific types of
exceptional conditions that are not covered by the standard exceptions provided
by Java. Here's how you can define your own exceptions:

1. Create a Custom Exception Class:

To define a custom exception, you need to create a new class that

extends an existing exception class or one of its subclasses.

It is common to extend the Exception class or one of its subclasses,

such as RuntimeException .

You can add additional fields, constructors, and methods to your custom
exception class as needed.

Example:

class CustomException extends Exception {

// Additional fields, constructors, and methods
}

2. Throwing Custom Exceptions:

Once you have defined your custom exception class, you can throw
instances of that exception when necessary.

JAVA 45
 Use the throw keyword followed by an instance of your custom
exception class to throw the exception.

Example:

void someMethod() throws CustomException {

if (/* some condition */) {
throw new CustomException("Custom exception message");
}
}

3. Catching Custom Exceptions:

To handle a custom exception, you can use a try-catch block to catch

and handle the exception.

Catch the custom exception type by specifying it in a catch block.

Example:

try {
someMethod();
} catch (CustomException e) {
// Handle the custom exception
}

4. Customizing Exception Messages:

You can provide a custom message for your exception by adding a

constructor to your custom exception class that accepts a string
message.

Example:

class CustomException extends Exception {

public CustomException(String message) {
super(message);
}
}

By creating your own exception classes, you can handle specific exceptional
situations in a more tailored and meaningful way. Custom exceptions allow you

JAVA 46
 to communicate and handle exceptional conditions specific to your application
domain.

Remember to follow Java naming conventions for custom exception class

names, and make sure to choose appropriate exception class hierarchy (e.g.,
extending Exception or RuntimeException ) based on whether the exception is
checked or unchecked.

The StringBuffer class in Java is a mutable sequence of characters. It is similar

to the String class, but unlike String , which is immutable (its value cannot be
changed once it is created), StringBuffer provides methods to modify its content.
It is commonly used when you need to perform extensive string manipulation
operations. Here's an overview of the StringBuffer class:

1. Creating a StringBuffer:

You can create a StringBuffer object using its empty constructor or by

passing an initial value to the constructor.

Example:

StringBuffer sb1 = new StringBuffer(); // Empty StringBuffer

StringBuffer sb2 = new StringBuffer("Hello"); // StringBuffer with initia
l value

2. Modifying the StringBuffer:

StringBuffer provides methods to append, insert, delete, and replace

characters in the string.

The append() method is used to add characters at the end of the existing
content.

The insert() method is used to insert characters at a specific position.

The delete() method is used to remove characters from a specific

range.

The replace() method is used to replace characters in a specific range

with new characters.

Example:

JAVA 47
 StringBuffer sb = new StringBuffer("Hello");
sb.append(" World"); // "Hello World"
sb.insert(5, ","); // "Hello, World"
sb.delete(5, 7); // "Hello World"
sb.replace(6, 11, "Java"); // "Hello Java"

3. Converting StringBuffer to String:

You can convert a StringBuffer object to a String using the toString()

method.

Example:

StringBuffer sb = new StringBuffer("Hello");

String str = sb.toString(); // "Hello"

4. Thread Safety:

StringBufferis designed to be thread-safe, meaning it can be safely

used in a multi-threaded environment where multiple threads may
access and modify the same StringBuffer object concurrently.

However, this thread safety comes at the cost of performance due to the
synchronization overhead.

If you don't require thread safety, you can use the non-thread-safe
alternative, StringBuilder , which provides similar functionality but without
the synchronization.

5. Performance Considerations:

While StringBuffer allows for efficient string manipulation, it can be less

performant compared to StringBuilder when used in a single-threaded
environment.

The synchronization overhead in StringBuffer can impact performance,

especially when performing a large number of string modifications.

If you're working in a single-threaded environment, consider using

StringBuilder for better performance.

The StringBuffer class provides a convenient and efficient way to manipulate

mutable strings in Java. It offers various methods for modifying the content of the

JAVA 48
 string and can be used in both single-threaded and multi-threaded scenarios.

Tokenizer

The StringTokenizer class in Java is used to break a string into smaller tokens or
parts, based on a specified delimiter. It provides a simple and convenient way to
tokenize strings. Here's an overview of the StringTokenizer class:

1. Creating a StringTokenizer:

To create a StringTokenizer object, you need to pass the input string and
the delimiter to its constructor.

The delimiter can be a single character or a string of multiple characters.

Example:

String input = "Hello,World,Java";

StringTokenizer tokenizer = new StringTokenizer(input, ",");

2. Retrieving Tokens:

You can use the hasMoreTokens() method to check if there are more
tokens available in the input string.

The nextToken() method is used to retrieve the next token from the input
string.

Example:

while (tokenizer.hasMoreTokens()) {
String token = tokenizer.nextToken();
// Process the token
}

3. Changing Delimiters:

By default, the StringTokenizer uses whitespace as the delimiter.

You can change the delimiter by using the overloaded constructor or the
setDelimiter() method.

Example:

JAVA 49
 String input = "Hello-World-Java";
StringTokenizer tokenizer = new StringTokenizer(input, "-");

4. Counting Tokens:

You can use the countTokens() method to get the total number of tokens
remaining in the tokenizer.

Example:

int count = tokenizer.countTokens();

5. Handling Empty Tokens:

By default, empty tokens (consecutive delimiters) are not skipped.

You can specify a second parameter in the constructor as true to

enable empty token skipping.

Example:

String input = "Hello,,World,,Java";

StringTokenizer tokenizer = new StringTokenizer(input, ",", true);

6. Retrieving Delimiters:

You can use the nextDelimiter() method to retrieve the delimiters as

tokens.

Example:

while (tokenizer.hasMoreTokens()) {
String token = tokenizer.nextToken();
if (tokenizer.hasMoreTokens()) {
String delimiter = tokenizer.nextDelimiter();
// Process the delimiter
}
}

The StringTokenizer class provides a straightforward way to split a string into

tokens using a specified delimiter. It is particularly useful when you need to

JAVA 50
 process delimited data or extract specific parts from a string.
However, note that the StringTokenizer class is considered legacy and has been
largely replaced by the String.split() method and regular expressions ( Pattern
and Matcher classes) for more advanced string parsing and splitting
requirements.

Applets
Applets are small Java programs that are designed to run within a web browser.
They were a popular way to add interactive content to web pages in the past, but
their usage has significantly decreased due to security concerns and the
emergence of alternative technologies. Nevertheless, understanding applets and
their lifecycle can provide insights into the history of web development. Let's
delve into the details of applets, their lifecycle, and security concerns:

1. Applets:

Applets are Java programs that are embedded in HTML web pages and
run in a sandboxed environment within a web browser.

They were initially introduced as a way to provide dynamic and

interactive content on the web.

Applets were rendered using the Java Applet Viewer or a web browser
with Java plugin support.

2. Applet Lifecycle:

An applet goes through several stages during its lifecycle:

Initialization: The applet is loaded by the browser, and its init()

method is called. This method is used to perform initialization tasks
such as setting up the user interface.

Start: The applet's start() method is called, indicating that the

applet is about to start running.

Running: The applet is in the running state. Its paint() method is

called to render the applet's visual output on the web page.

Stop: The applet's stop() method is called when the applet is no

longer visible on the web page, such as when the user switches to

JAVA 51
 another page or closes the browser window.

Destroy: The applet's destroy() method is called when the applet is

no longer needed. It allows the applet to clean up resources and
release any held references.

The lifecycle methods can be overridden in the applet's code to perform

specific actions at each stage.

3. Security Concerns:

Applets raised significant security concerns due to their ability to access

system resources and execute potentially malicious code.

Security restrictions were imposed to prevent untrusted applets from

performing harmful actions on the user's machine.

Sandboxing: Applets run in a restricted environment known as the

"sandbox" to prevent unauthorized access to system resources. They
have limited permissions and are prevented from performing potentially
dangerous operations.

Security Manager: The Java security model introduced the concept of a

"security manager" that enforces security policies for applets. It controls
applet permissions and determines what applets can and cannot do.

Permissions: Applets can be granted specific permissions to access

certain resources or perform restricted operations. These permissions
need to be explicitly granted by the user or the browser.

4. Deprecation and Alternatives:

Due to security concerns, browser compatibility issues, and the rise of

alternative technologies like JavaScript, the usage of applets has
significantly declined.

Modern web development favors HTML5, CSS, and JavaScript for

creating interactive web content.

Java Web Start: As an alternative to applets, Java Web Start was

introduced. It allows the delivery of full-fledged Java applications over
the web, eliminating the security restrictions imposed on applets.

JAVA 52
 It's important to note that as of Java 11, the Java Plugin and Applet API have
been deprecated and removed from the Java Development Kit (JDK). Therefore,
applets are no longer supported in modern browsers.

Here are a couple of examples to illustrate the usage of applets and their
lifecycle:

Example 1: Simple Applet

import java.applet.Applet;
import java.awt.Graphics;

public class SimpleApplet extends Applet {

public void init() {

// Initialization code
}

public void start() {

// Start code
}

public void paint(Graphics g) {

// Rendering code
g.drawString("Hello, Applet!", 50, 50);
}

public void stop() {

// Stop code
}

public void destroy() {

// Cleanup code
}
}

Example 2: Interactive Applet with Mouse Interaction

import java.applet.Applet;
import java.awt.Graphics;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

public class InteractiveApplet extends Applet implements MouseListener {

public void init() {

// Initialization code

JAVA 53
 addMouseListener(this);
}

public void start() {

// Start code
}

public void paint(Graphics g) {

// Rendering code
g.drawString("Click to change color!", 50, 50);
}

public void stop() {

// Stop code
}

public void destroy() {

// Cleanup code
}

public void mouseClicked(MouseEvent e) {

// Change color on mouse click
int red = (int) (Math.random() * 256);
int green = (int) (Math.random() * 256);
int blue = (int) (Math.random() * 256);
setBackground(new Color(red, green, blue));
repaint();
}

public void mousePressed(MouseEvent e) {

// Mouse press event
}

public void mouseReleased(MouseEvent e) {

// Mouse release event
}

public void mouseEntered(MouseEvent e) {

// Mouse enter event
}

public void mouseExited(MouseEvent e) {

// Mouse exit event
}
}

In Example 1, we have a simple applet that displays the message "Hello,

Applet!" using the paint() method. The init() , start() , stop() , and destroy()
methods are present to handle the applet lifecycle.

In Example 2, we have an interactive applet that changes its background color

randomly on each mouse click. It implements the MouseListener interface to

JAVA 54
 handle mouse events. The mouseClicked() method is overridden to change the
background color and trigger a repaint of the applet.

UNIT - 3
Threads
Threads are a fundamental concept in Java that allow concurrent execution of
code. They are lightweight units of execution within a program, enabling multiple
tasks to run concurrently. Here are the key aspects of threads:

Threads enable concurrent execution, where multiple parts of a program can

execute independently and concurrently.

By default, Java programs have at least one thread, known as the main
thread, which is created automatically when the program starts.

Threads can be used to perform tasks in the background, handle multiple

client requests, or improve the responsiveness of a user interface.

Creating Threads:
In Java, there are two main ways to create threads:

Extending the Thread class:

You can create a thread by extending the Thread class and overriding its
run() method, which contains the code to be executed by the thread.

Here's an example:

class MyThread extends Thread {

public void run() {
// Code to be executed by the thread
}
}

To start the thread, create an instance of the MyThread class and call its
start() method.

Implementing the Runnable interface:

JAVA 55
 Alternatively, you can create a thread by implementing the Runnable
interface and passing an instance of it to the Thread constructor.

Here's an example:

class MyRunnable implements Runnable {

public void run() {
// Code to be executed by the thread
}
}

To start the thread, create an instance of the MyRunnable class, create a

Threadobject by passing the MyRunnable instance to the constructor, and
then call the start() method on the Thread object.

Thread Priority:
Threads in Java can have different priorities, ranging from 1 (lowest) to 10
(highest). The default priority is 5. Here are some points to know about thread
priority:

Thread priorities are used by the thread scheduler to determine the order of
execution when multiple threads are ready to run.

You can set the priority of a thread using the setPriority() method, passing
the desired priority as an argument.

Higher priority threads have a greater chance of being scheduled for

execution, but it is not guaranteed.

Thread priority should be used with caution and should not be solely relied
upon for critical operations.

Blocked States:
Threads can enter into blocked states in certain situations. Here are two
common scenarios:

Sleeping: A thread can enter a blocked state by invoking the Thread.sleep()

method, which causes the thread to pause execution for a specified period
of time.

Waiting: Threads can wait for a specific condition to be met using the wait()

method. This method is typically used in multi-threaded programs where one

thread waits for a signal from another thread before continuing its execution.

JAVA 56
 Extending the Thread Class:
As mentioned earlier, one way to create threads is by extending the Thread

class. Here are some points to understand:

When extending the Thread class, you override the run() method to define
the behavior of the thread.

By extending the Thread class, your class becomes a thread itself and can
be instantiated and started like any other thread.

However, this approach limits the flexibility of your class, as it does not allow
for extending other classes.

If you've created a thread by extending the Thread class, you can simply
create an instance of your class and call the start() method on it.

Example:

javaCopy code
MyThread myThread = new MyThread(); // Assuming MyThread extends Thread
myThread.start();

It's important to note that concurrent programming and managing threads can be
complex, as it involves synchronization, thread safety, and coordination between
threads. It's recommended to study these topics further to write robust and
efficient multi-threaded programs.

Runnable Interface
The Runnable interface in Java provides an alternative way to create threads by
encapsulating the code to be executed within a separate object. Here's an
overview of the Runnable interface:

1. Definition and Purpose:

The Runnable interface is defined in the java.lang package and contains a
single method called run() . Its purpose is to represent a task or unit of work
that can be executed by a thread.

2. Implementing the Runnable Interface:

To create a thread using the Runnable interface, follow these steps:

JAVA 57
 Create a class that implements the Runnable interface.

Implement the run() method within the class, which contains the code to be
executed by the thread.

Instantiate a Thread object, passing an instance of your class as a

constructor argument.

Call the start() method on the Thread object to start the execution of the
thread.

Here's an example to illustrate the usage of the Runnable interface:

class MyRunnable implements Runnable {

public void run() {
// Code to be executed by the thread
}
}

public class RunnableExample {

public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();
}
}

In the example above, we create a class MyRunnable that implements the

Runnable interface and overrides the run() method. Then, we create an instance

of MyRunnable and pass it to the Thread constructor. Finally, we start the thread by
calling the start() method.

Benefits of Using the Runnable Interface:

Using the Runnable interface has several advantages over extending the Thread

class directly:

Flexibility: Implementing the Runnable interface allows you to separate the

thread's behavior from the class hierarchy. You can still extend other classes
and implement multiple interfaces while defining the thread's behavior in a
separate Runnable object.

Code Reusability: Since the thread's behavior is encapsulated in a Runnable

object, you can reuse the object and share it among multiple threads if
needed.

JAVA 58
 Enhanced Thread Pooling: When utilizing thread pooling techniques, such
as the Executor framework, using Runnable objects allows for more efficient
utilization of thread resources.

By utilizing the Runnable interface, you can design your code to be more flexible,
modular, and scalable when dealing with multi-threaded scenarios.

Thread Synchronization:
In multi-threaded programming, thread synchronization is important to ensure
proper coordination and order of execution between threads. It helps prevent
data inconsistency and race conditions. Java provides synchronization
mechanisms to achieve thread synchronization:

1. Synchronized Methods:

By using the synchronized keyword, you can declare a method as

synchronized.

When a thread enters a synchronized method, it acquires the lock on the

object, and other threads must wait until the lock is released.

Example:

public synchronized void synchronizedMethod() {

// Synchronized method code
}

2. Synchronized Blocks:

You can also synchronize specific blocks of code using the synchronized

keyword with an object as a lock.

The lock ensures that only one thread can execute the synchronized
block at a time.

Example:

synchronized (lockObject) {
// Synchronized block code
}

JAVA 59
 Synchronize Threads:
To synchronize threads and ensure proper coordination, you can use methods
like wait() , notify() , and notifyAll() . These methods must be called from
within a synchronized context (synchronized method or synchronized block).
Here's an overview:

wait() : Causes the current thread to release the lock and enter a waiting
state until another thread calls notify() or notifyAll() on the same object. It
should be used within a loop to check the condition that caused the thread to
wait.

: Wakes up one of the threads that are waiting on the same object.
notify()

The awakened thread can then compete for the lock and continue execution.

notifyAll() : Wakes up all the threads that are waiting on the same object.

By using synchronization and the methods mentioned above, you can control the
execution order and synchronization between threads, ensuring proper
concurrency and data consistency.

Sync Code Block:

In addition to synchronizing entire methods, Java also allows you to synchronize
specific blocks of code using synchronized code blocks. This gives you more
fine-grained control over synchronization. Here's how you can use sync code
blocks:

1. Syntax:

synchronized (object) {
// Synchronized code block
}

2. Object Lock:

The synchronized code block requires an object as a lock to coordinate

the execution of threads.

The lock can be any object, but it is commonly a shared object that the
threads need to synchronize on.

JAVA 60
 Only one thread can hold the lock at a time, and other threads will wait
until the lock is released.

3. Benefits:

Sync code blocks allow you to synchronize only the critical section of
code that needs synchronization, rather than the entire method.

This approach can lead to improved performance by reducing the

amount of time other threads spend waiting for the lock.

Here's an example to illustrate the usage of sync code blocks:

public class SyncCodeBlockExample {

private static int count = 0;
private static final Object lock = new Object();

public static void increment() {

synchronized (lock) {
count++;
}
}

public static void main(String[] args) {

Runnable runnable = () -> {
for (int i = 0; i < 1000; i++) {
increment();
}
};

Thread thread1 = new Thread(runnable);

Thread thread2 = new Thread(runnable);

thread1.start();
thread2.start();

try {
thread1.join();
thread2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}

System.out.println("Count: " + count);

}
}

In the example above, we have a shared count variable that we want to

increment concurrently. We use a synchronized code block with the lock object

JAVA 61
 to ensure that only one thread can modify the count variable at a time.

Overriding Synchronized Methods:

When dealing with inheritance and overriding methods in Java, there are a few
things to consider when it comes to synchronized methods:

1. Overriding a Synchronized Method:

If a superclass has a synchronized method, and a subclass overrides

that method, the subclass's method is not automatically synchronized.

The subclass can choose to synchronize the method explicitly if

synchronization is required.

2. Adding Synchronization to Overridden Methods:

If a subclass wants to synchronize an overridden method, it can do so

by using the synchronized keyword in the method declaration.

Example:

class SuperClass {
public synchronized void synchronizedMethod() {
// Superclass synchronized method
}
}

class SubClass extends SuperClass {

@Override
public synchronized void synchronizedMethod() {
// Subclass synchronized method
}
}

In the example above, the SuperClass has a synchronized method. The SubClass

overrides the method and adds the synchronized keyword to synchronize it

again.

Thread Communication
Thread Communication using wait(), notify(), and notifyAll():

In Java, threads can communicate with each other using the methods wait() ,
notify() , and notifyAll() . These methods are part of the Object class and can

JAVA 62
 be used to coordinate the execution of threads. Here's an explanation of how
these methods work:

1. wait():

The wait() method causes the current thread to release the lock on the
object and enter a waiting state until another thread calls notify() or
notifyAll() on the same object.

When a thread calls wait() , it relinquishes the lock and allows other
threads to continue execution. The thread remains in a waiting state until
it receives a notification to resume.

Example:

synchronized (sharedObject) {
while (condition) {
sharedObject.wait(); // Waits until notified
}
// Continue execution after receiving notification
}

2. notify():

The notify() method wakes up one thread that is waiting on the same
object. It allows that thread to continue execution after it regains the
lock.

If multiple threads are waiting, the thread that gets the notification is
arbitrary and depends on the thread scheduler.

Example:

synchronized (sharedObject) {
// Update shared data or perform some task
sharedObject.notify(); // Notifies one waiting thread
}

3. notifyAll():

The notifyAll() method wakes up all threads that are waiting on the
same object. It allows all the waiting threads to continue execution after
they regain the lock.

JAVA 63
 Example:

synchronized (sharedObject) {
// Update shared data or perform some task
sharedObject.notifyAll(); // Notifies all waiting threads
}

Thread communication using wait() , notify() , and notifyAll() is typically used

in scenarios where one thread needs to wait for a specific condition to be met by
another thread before proceeding.

To ensure proper usage of these methods, the following guidelines are

recommended:

Call wait() , notify() , and notifyAll() only from within synchronized blocks
or synchronized methods.

Use a loop with wait() to check the condition that caused the thread to wait.
This helps prevent spurious wake-ups.

Make sure the threads involved are accessing the same shared object for
synchronization.

Thread communication is a powerful mechanism for coordination and

synchronization between threads. It enables efficient and controlled inter-thread
communication in complex concurrent scenarios.

AWT Components
AWT (Abstract Window Toolkit) is a set of classes and components in Java used
for creating graphical user interfaces (GUIs) for desktop applications. AWT
provides a collection of UI components that allow developers to create windows,
buttons, labels, text fields, and other elements to build interactive user
interfaces. Here are some commonly used AWT components:

1. Frame:

The Frame class represents a top-level window with a title bar and
borders.

It is the main container for building the application window.

JAVA 64
 Example:

Frame frame = new Frame("My Frame");

2. Panel:

The Panel class represents a container that can hold other components.

It is used to group and organize components within a window.

Example:

Panel panel = new Panel();

3. Button:

The Button class represents a push button component that triggers an

action when clicked.

It is used to perform specific actions in response to user interaction.

Example:

Button button = new Button("Click me");

4. Label:

The Label class represents a non-editable text component used to

display information or instructions.

It is used for providing static text in the GUI.

Example:

Label label = new Label("Welcome!");

5. TextField:

The TextField class represents a single-line input field where users can
enter text.

JAVA 65
 It is used for accepting user input or displaying dynamic text.

Example:

TextField textField = new TextField(20);

6. TextArea:

The TextArea class represents a multi-line text area where users can
enter or view large amounts of text.

It is used for accepting or displaying longer text content.

Example:

TextArea textArea = new TextArea(5, 30);

7. Checkbox:

The Checkbox class represents a component that can be checked or

unchecked.

It is used for presenting options or boolean values.

Example:

Checkbox checkbox = new Checkbox("Remember me");

These are just a few examples of AWT components. AWT provides many more
components such as List, Choice, Scrollbar, Menu, etc., which you can use to
create rich and interactive GUIs in Java.

To use AWT components, you need to import the relevant classes from the
java.awt package.

Component Class and Container Class:

In Java's AWT (Abstract Window Toolkit), the Component class and the Container
class are fundamental classes that form the building blocks of graphical user
interfaces. These classes provide the foundation for creating and managing GUI
components within a window. Let's take a closer look at each class:

JAVA 66
 1. Component Class:

The Component class is an abstract class that serves as the base class
for all AWT components.

It represents a visual entity that can be added to a graphical user

interface.

Examples of subclasses of Component include Button, Label, TextField,

etc.

Key methods and properties of the Component class include:

setSize(int width, int height) : Sets the size of the component.

setLocation(int x, int y) : Sets the position of the component within

its container.

setVisible(boolean visible) : Sets the visibility of the component.

setEnabled(boolean enabled) : Sets whether the component is enabled

or disabled.

setBackground(Color color) : Sets the background color of the

component.

setForeground(Color color) : Sets the foreground color (text color) of

the component.

2. Container Class:

The Container class is a subclass of Component and serves as a

container for other components.

It represents a rectangular area that can hold and organize other

components.

Examples of subclasses of Container include Panel, Frame, and

Window.

Key methods and properties of the Container class include:

add(Component comp) : Adds a component to the container.

remove(Component comp) : Removes a component from the container.

JAVA 67
 : Sets the layout manager for the
setLayout(LayoutManager manager)

container to define how components are arranged.

validate() : Forces the container to re-layout its components.

getComponent(int index) : Returns the component at the specified

index within the container.

getComponents() : Returns an array of all the components in the

container.

The Component class and the Container class provide the basic functionality for
creating and managing GUI components in AWT. By subclassing these classes
and utilizing their methods and properties, you can build complex and interactive
user interfaces in Java.

Layout Manager Interface and Default Layouts:

In Java's AWT (Abstract Window Toolkit), the Layout Manager interface and its
various implementations are used to define how components are arranged and
displayed within containers. The Layout Manager provides automatic positioning
and sizing of components, ensuring that they adapt well to different window
sizes and screen resolutions. Let's explore the Layout Manager interface and
some of its default layouts:

1. Layout Manager Interface:

The LayoutManager interface is the base interface for all layout managers
in AWT.

It defines the methods that layout managers must implement to arrange

components within containers.

Key methods of the LayoutManager interface include:

void addLayoutComponent(String name, Component comp) : Adds a named

component to the layout.

void removeLayoutComponent(Component comp) : Removes a component

from the layout.

Dimension preferredLayoutSize(Container parent) : Returns the preferred

size of the layout.

JAVA 68
 Dimension minimumLayoutSize(Container parent) : Returns the minimum
size of the layout.

void layoutContainer(Container parent) : Arranges the components

within the container.

2. Default Layouts:
AWT provides several default layout managers that implement the
LayoutManager interface. These layouts handle the positioning and sizing of

components in different ways. Here are some commonly used default

layouts:

FlowLayout:

The FlowLayout arranges components in a left-to-right flow, wrapping

to the next line when the current line is full.

It respects the preferred size of components and maintains their

relative order.

Example:

Container container = new Container();

container.setLayout(new FlowLayout());

BorderLayout:

The BorderLayout divides the container into five regions: North,

South, East, West, and Center.

Components are placed in these regions, and the layout manages

their sizing and positioning.

Example:

Container container = new Container();

container.setLayout(new BorderLayout());

GridLayout:

The GridLayout arranges components in a grid of rows and columns.

All components are evenly sized to fit the available space.

JAVA 69
 Example:

Container container = new Container();

container.setLayout(new GridLayout(rows, columns));

GridBagLayout:

The GridBagLayout provides a flexible and powerful layout

management system.

It uses constraints to define the positioning and sizing of

components.

Example:

Container container = new Container();

container.setLayout(new GridBagLayout());

These are just a few examples of default layouts available in AWT. Each
layout manager has its own set of properties and behavior, allowing you to
choose the most appropriate one for your GUI design.

By utilizing the Layout Manager interface and selecting the appropriate layout
manager, you can create well-structured and responsive user interfaces in Java.

Insets and Dimensions:

In Java's AWT (Abstract Window Toolkit), Insets and Dimensions are classes
that provide useful functionality for managing the size and positioning of
components within containers. Let's explore these classes in more detail:

1. Insets:

The Insets class represents the borders of a container.

It defines the distances between the edges of a container and its

components.

Insets are often used to control the spacing between components or to

create padding around a container.

Key methods of the Insets class include:

JAVA 70
 int top: Represents the top inset (distance from the top edge of the
container).

int left: Represents the left inset (distance from the left edge of
the container).

int bottom : Represents the bottom inset (distance from the bottom
edge of the container).

int right : Represents the right inset (distance from the right edge of
the container).

Example usage of Insets :

Insets insets = new Insets(top, left, bottom, right);

2. Dimensions:

The Dimension class represents the size of a component or container.

It encapsulates the width and height values.

Dimensions are commonly used to define the preferred, minimum, or

maximum size of components.

Key methods of the Dimension class include:

int width : Represents the width of the dimension.

int height : Represents the height of the dimension.

Example usage of Dimension :

Dimension dimension = new Dimension(width, height);

It's worth noting that both Insets and Dimension are immutable classes,
meaning their values cannot be changed once set. To modify their values,
you would typically create new instances with the desired values.

These classes are often used in conjunction with layout managers to control the
size, spacing, and positioning of components within containers. They provide a
convenient way to manage the visual aspects of GUI design.

JAVA 71
 Border Layout:
The BorderLayout is a default layout manager provided by AWT.

It divides the container into five regions: North, South, East, West, and
Center.

Each region can hold only one component.

The components added to the BorderLayout are automatically resized to fit

their respective regions.

Example usage:

Container container = new Container();

container.setLayout(new BorderLayout());
container.add(component, BorderLayout.NORTH);

Flow Layout:
The FlowLayout is a default layout manager provided by AWT.

It arranges components in a left-to-right flow, wrapping to the next line when

the current line is full.

It respects the preferred size of components and maintains their relative

order.

Example usage:

Container container = new Container();

container.setLayout(new FlowLayout());
container.add(component1);
container.add(component2);

Grid Layout:

The GridLayout is a default layout manager provided by AWT.

It arranges components in a grid of rows and columns.

All components are evenly sized to fit the available space.

Example usage:

JAVA 72
 Container container = new Container();
container.setLayout(new GridLayout(rows, columns));
container.add(component1);
container.add(component2);

These layout managers are commonly used in Java GUI applications to organize
components within containers. By selecting the appropriate layout manager and
adding components to the specified regions or grid cells, you can create visually
appealing and responsive user interfaces.

Card Layout:
The CardLayout is a default layout manager provided by AWT.

It allows multiple components to be stacked on top of each other, with only

one component visible at a time.

It is often used to create multi-pane interfaces, such as wizards or tabbed

views.

Components are added to the CardLayout using unique names, and you can
switch between components using methods like next() , previous() , or
show() .

Example usage:

Container container = new Container();

container.setLayout(new CardLayout());
container.add(component1, "card1");
container.add(component2, "card2");

Grid Bag Layout:

The GridBagLayout is a flexible layout manager provided by AWT.

It allows components to be arranged in a grid-like structure with

customizable cell sizes and positioning.

It offers fine-grained control over component placement using constraints

such as grid coordinates, weights, and alignments.

Example usage:

JAVA 73
 Container container = new Container();
container.setLayout(new GridBagLayout());
GridBagConstraints constraints = new GridBagConstraints();
constraints.gridx = 0;
constraints.gridy = 0;
container.add(component1, constraints);
constraints.gridx = 1;
constraints.gridy = 0;
container.add(component2, constraints);

AWT Events:
AWT provides a set of event classes and interfaces to handle user
interactions with GUI components.

Some commonly used AWT events include:

ActionEvent: Generated when a button or menu item is clicked.

MouseEvent: Generated when the mouse is moved or clicked.

KeyEvent: Generated when a key is pressed or released.

WindowEvent: Generated when a window is opened, closed, or resized.

To handle AWT events, you need to implement event listener interfaces and
register them with the appropriate components using methods like
addActionListener() , addMouseListener() , or addKeyListener() .

Example usage:

button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
// Handle button click event
}
});

These layout managers and event handling mechanisms in AWT allow you to
create dynamic and interactive user interfaces in your Java applications.

Event Models:
In Java, there are different event models that define how events are generated,
dispatched, and handled in graphical user interfaces (GUIs). The two main event

JAVA 74
 models used in Java are the AWT event model and the Swing event model. Let's
explore each of them:

1. AWT Event Model:

The AWT (Abstract Window Toolkit) event model is the original event
model in Java.

It is based on the delegation model, where components delegate event

handling to their registered listeners.

In the AWT event model, events are generated by the operating system
and delivered to the appropriate components.

The event handling process involves three main steps: event generation,
event dispatching, and event handling.

Key classes in the AWT event model include:

EventObject: The base class for all AWT events.

EventListener: The base interface for all AWT event listeners.

EventListenerProxy: A proxy class for event listeners.

EventListenerList: A container class to manage event listeners.

2. Swing Event Model:

The Swing event model is an enhanced version of the AWT event model
and is built on top of it.

It provides a more powerful and flexible event handling mechanism for

Swing components.

The Swing event model introduces the concept of "pluggable look and
feel" (PLAF) and "lightweight" components.

Swing events are dispatched by the Swing event-dispatching thread

(EDT), which ensures that all GUI events are handled in a single thread.

Key classes in the Swing event model include:

EventObject: The base class for all Swing events.

EventListener: The base interface for all Swing event listeners.

JAVA 75
 EventListenerList: A container class to manage Swing event
listeners.

SwingUtilities: A utility class for working with Swing components and

threads.

Both event models provide a similar set of event classes and interfaces, but the
Swing event model offers more features and flexibility for GUI development.

To handle events in Java, you need to implement event listener interfaces and
register them with the appropriate components. Common event listener
interfaces include ActionListener, MouseListener, KeyListener, etc. The actual
event handling code is written within the implemented listener methods.

Example usage:

button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
// Handle button click event
}
});

textField.addKeyListener(new KeyListener() {
public void keyPressed(KeyEvent e) {
// Handle key press event
}

public void keyReleased(KeyEvent e) {

// Handle key release event
}

public void keyTyped(KeyEvent e) {

// Handle key typed event
}
});

By understanding the event models and utilizing event listeners, you can create
interactive and responsive GUI applications in Java.

Listeners:
In Java, listeners are interfaces that define callback methods to handle specific
events. They are used in event-driven programming to capture and respond to
user actions or system events. Here are the key points about listeners:

JAVA 76
 Listeners are implemented as interfaces in Java. Each listener interface
defines one or more methods that need to be implemented to handle
specific events.

Listeners follow the Observer design pattern, where the listener objects
register themselves with the event source to receive notifications when the
corresponding events occur.

When an event occurs, the event source invokes the appropriate methods
on the registered listeners, passing relevant information about the event.

Listeners decouple the event source from event handling logic, allowing for
flexible and modular design of event-driven systems.

Here are a few commonly used listeners in Java:

1. ActionListener: Used to handle action events, such as button clicks or menu

item selections.

2. MouseListener: Handles mouse-related events, including mouse clicks,

movements, and enters/exits.

3. KeyListener: Deals with keyboard events, such as key presses, releases,

and typing.

4. ItemListener: Listens to item events, commonly used with checkboxes or

radio buttons.

5. FocusListener: Responds to focus events when a component gains or loses

focus.

6. WindowListener: Handles window-related events, like opening, closing, or

resizing of windows.

Example usage of ActionListener:

button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
// Handle button click event
}
});

Class Listener:

JAVA 77
 The term "Class Listener" refers to a design pattern where a separate class is
created to implement a listener interface. This approach provides better
modularity and separation of concerns. Instead of using anonymous inner
classes or implementing the listener interface in the same class, you create a
separate class dedicated to handling events.
Here's an example of implementing a class listener:

1. Define a listener class that implements the desired listener interface and
overrides the corresponding event handling methods.

public class MyActionListener implements ActionListener {

public void actionPerformed(ActionEvent e) {
// Handle the action event here
}
}

1. Instantiate the listener class and register it with the event source.

MyActionListener listener = new MyActionListener();

button.addActionListener(listener);

Using class listeners allows for cleaner code organization, improved reusability,
and easier maintenance, especially when multiple components need to share
the same event handling logic.

Adapters:
In Java, adapters are classes that provide default implementations for listener
interfaces. They allow you to implement only the methods you need, rather than
having to provide empty implementations for all methods in the interface.
Adapters are useful when you want to listen to specific events and avoid writing
unnecessary code. Here are the key points about adapters:

Adapters are classes that implement a listener interface and provide default
implementations for all the methods in the interface.

The adapter class acts as a bridge between the event source and the
listener, allowing you to override only the methods you are interested in.

JAVA 78
 By using adapters, you can avoid implementing all methods of the listener
interface, which can save time and reduce code clutter.

Here's an example to illustrate the usage of an adapter class:

1. Define an adapter class that extends the appropriate adapter class for the
listener interface you want to use. For example, if you want to handle mouse
events, you can extend the MouseAdapter class, which provides empty
implementations for all methods in the MouseListener interface.

public class MyMouseListener extends MouseAdapter {

public void mouseClicked(MouseEvent e) {
// Handle mouse click event
}
}

1. Instantiate the adapter class and register it with the event source.

MyMouseListener mouseListener = new MyMouseListener();

component.addMouseListener(mouseListener);

In this example, the MyMouseListener class extends the MouseAdapter class

and overrides the mouseClicked() method to handle mouse click events. By doing
so, you don't have to provide empty implementations for other methods in the
MouseListener interface.

Using adapters simplifies event handling code, especially when you are
interested in handling a specific subset of events provided by a listener interface.
It allows you to focus on the events that matter to you without having to
implement unnecessary methods.

Action Event Methods:

The ActionEvent class represents an action event, which is typically generated
by user actions like button clicks or menu item selections. It provides useful
methods to retrieve information about the event. Here are some commonly used
methods of the ActionEvent class:

1. getSource(): Returns the object that generated the event. Useful when
multiple components share the same ActionListener.

JAVA 79
 Object source = event.getSource();

1. getActionCommand(): Returns the command string associated with the

event source. Useful when using the same ActionListener for multiple
components and distinguishing between them based on the command.

String command = event.getActionCommand();

1. getModifiers(): Returns the modifiers associated with the event, such as Ctrl,
Shift, or Alt keys.

int modifiers = event.getModifiers();

Focus Event Methods:

The FocusEvent class represents focus-related events, such as when a
component gains or loses focus. It provides methods to obtain information about
the event. Here are some commonly used methods of the FocusEvent class:

1. getSource(): Returns the object that generated the event.

Object source = event.getSource();

1. isTemporary(): Returns true if the focus change is temporary, such as when

a popup or dialog receives temporary focus.

boolean temporary = event.isTemporary();

Key Event Methods:

The KeyEvent class represents keyboard events, including key presses,
releases, and typed characters. It provides methods to retrieve information about
the event. Here are some commonly used methods of the KeyEvent class:

1. getKeyCode(): Returns the unique code for the key that triggered the event.

JAVA 80
 int keyCode = event.getKeyCode();

1. getKeyChar(): Returns the character representation of the key that triggered

the event.

char keyChar = event.getKeyChar();

1. isShiftDown(), isCtrlDown(), isAltDown(): Returns true if the Shift, Ctrl, or Alt

key was pressed during the event.

boolean shiftDown = event.isShiftDown();

boolean ctrlDown = event.isCtrlDown();
boolean altDown = event.isAltDown();

These methods allow you to extract relevant information from ActionEvent,

FocusEvent, and KeyEvent objects and perform appropriate actions based on
the user's input or component focus.

Mouse Events:
Mouse events in Java are triggered by user interactions with the mouse, such as
clicking, moving, or scrolling. There are several types of mouse events available
in Java, including:

1. MouseListener: This interface provides methods to handle basic mouse

events. Some commonly used methods include:

mouseClicked(MouseEvent e): Invoked when the mouse is clicked

(pressed and released) on a component.

mousePressed(MouseEvent e): Invoked when a mouse button is

pressed on a component.

mouseReleased(MouseEvent e): Invoked when a mouse button is

released on a component.

mouseEntered(MouseEvent e): Invoked when the mouse enters a

component.

JAVA 81
 mouseExited(MouseEvent e): Invoked when the mouse exits a
component.

2. MouseMotionListener: This interface provides methods to handle mouse

motion events. Some commonly used methods include:

mouseMoved(MouseEvent e): Invoked when the mouse is moved

without any buttons being pressed.

mouseDragged(MouseEvent e): Invoked when the mouse is moved with

a button being pressed.

3. MouseWheelListener: This interface provides a method to handle mouse

wheel events.

mouseWheelMoved(MouseWheelEvent e): Invoked when the mouse

wheel is rotated.

Here's an example of implementing a MouseListener and MouseMotionListener:

class MyMouseListener implements MouseListener, MouseMotionListener {

public void mouseClicked(MouseEvent e) {
// Handle mouse clicked event
}

public void mousePressed(MouseEvent e) {

// Handle mouse pressed event
}

public void mouseReleased(MouseEvent e) {

// Handle mouse released event
}

public void mouseEntered(MouseEvent e) {

// Handle mouse entered event
}

public void mouseExited(MouseEvent e) {

// Handle mouse exited event
}

public void mouseMoved(MouseEvent e) {

// Handle mouse moved event
}

public void mouseDragged(MouseEvent e) {

// Handle mouse dragged event
}
}

JAVA 82
 Window Events:
Window events are related to the state and behavior of windows, such as
opening, closing, resizing, or moving windows. In Java, you can handle window
events using the WindowListener interface. Some commonly used methods in
the WindowListener interface include:

windowOpened(WindowEvent e): Invoked when a window is first opened.

windowClosing(WindowEvent e): Invoked when the user attempts to close

the window.

windowClosed(WindowEvent e): Invoked when the window has been closed.

windowIconified(WindowEvent e): Invoked when the window is minimized

(iconified).

windowDeiconified(WindowEvent e): Invoked when the window is restored

from a minimized state.

windowActivated(WindowEvent e): Invoked when the window becomes the

active window.

windowDeactivated(WindowEvent e): Invoked when the window is no longer

the active window.

To handle window events, you can implement the WindowListener interface:

class MyWindowListener implements WindowListener {

public void windowOpened(WindowEvent e) {
// Handle window opened event
}

public void windowClosing(WindowEvent e) {

// Handle window closing event
}

public void windowClosed(WindowEvent e) {

// Handle window closed event
}

public void windowIconified(WindowEvent e) {

// Handle window iconified event
}

public void windowDeiconified(WindowEvent e) {

// Handle window deiconified event

JAVA 83
 }

public void windowActivated(WindowEvent e) {

// Handle window activated event
}

public void windowDeactivated(WindowEvent e) {

// Handle window deactivated event
}
}

You can then attach the window listener to a window object using the add

WindowListener() method.

frame.addWindowListener(new MyWindowListener());

By implementing the appropriate listener interfaces and their methods, you can
respond to user interactions with the mouse and handle various window-related
events in your Java programs.

UNIT - 4
Input/Output Streams:
In Java, input and output streams are used to handle the flow of data between a
program and an external source or destination, such as files, network
connections, or standard input/output. Streams provide a convenient way to read
data from and write data to these sources or destinations. Here are the key
points about input and output streams:

Input Streams: Input streams are used to read data from a source. They
provide methods to read different types of data, such as bytes, characters, or
objects, from the source. Some commonly used input stream classes include:

FileInputStream: Reads data from a file as a sequence of bytes.

FileReader: Reads data from a file as a sequence of characters.

ObjectInputStream: Reads serialized objects from a source.

JAVA 84
 Example of reading from a file using FileInputStream:

try (FileInputStream fis = new FileInputStream("file.txt")) {

int byteData;
while ((byteData = fis.read()) != -1) {
// Process the byte data
}
} catch (IOException e) {
e.printStackTrace();
}

Output Streams: Output streams are used to write data to a destination. They
provide methods to write different types of data to the destination. Some
commonly used output stream classes include:

FileOutputStream: Writes data to a file as a sequence of bytes.

FileWriter: Writes data to a file as a sequence of characters.

ObjectOutputStream: Writes serialized objects to a destination.

Example of writing to a file using FileOutputStream:

try (FileOutputStream fos = new FileOutputStream("file.txt")) {

String data = "Hello, World!";
byte[] byteData = data.getBytes();
fos.write(byteData);
} catch (IOException e) {
e.printStackTrace();
}

Byte Streams vs. Character Streams: Byte streams are used for reading and
writing binary data, while character streams are used for reading and writing
textual data. Character streams automatically handle character encoding and
decoding, making them suitable for working with text files.

Example of using character streams:

try (FileReader reader = new FileReader("file.txt")) {

int charData;
while ((charData = reader.read()) != -1) {
// Process the character data
}
} catch (IOException e) {

JAVA 85
 e.printStackTrace();
}

These are some of the basic concepts and classes related to input and output
streams in Java. They provide a flexible and efficient way to handle data input
and output in various scenarios.

Stream Filters:
Stream filters in Java provide a way to transform data as it passes through an
input or output stream. They are used to perform operations such as
compression, encryption, or data manipulation on the data being read from or
written to a stream. Stream filters are implemented using the decorator design
pattern, where a filter class wraps around an existing stream and modifies its
behavior.

The java.io package provides several classes for stream filters, including:

1. FilterInputStream and FilterOutputStream: These are abstract classes that

serve as the base classes for input and output stream filters. They provide a
default implementation that simply passes the data through unchanged. You
can extend these classes to create your own custom stream filters.

2. BufferedInputStream and BufferedOutputStream: These are examples of

stream filters that provide buffering capabilities. They wrap around an
existing input or output stream and improve performance by reducing the
number of I/O operations. BufferedInputStream reads data from an
underlying stream in chunks and stores it in an internal buffer, while
BufferedOutputStream writes data to an internal buffer before flushing it to
the underlying stream.

Example of using BufferedInputStream:

try (FileInputStream fis = new FileInputStream("file.txt");

BufferedInputStream bis = new BufferedInputStream(fis)) {
int byteData;
while ((byteData = bis.read()) != -1) {
// Process the byte data
}
} catch (IOException e) {
e.printStackTrace();
}

JAVA 86
 Data Input and Output Stream:
DataInputStream and DataOutputStream classes are used for reading and
writing primitive data types from/to a stream. They provide methods to read and
write data in a machine-independent format. These classes are particularly
useful when you need to exchange data between different platforms or systems.

Example of using DataOutputStream:

try (FileOutputStream fos = new FileOutputStream("file.dat");

DataOutputStream dos = new DataOutputStream(fos)) {
int intValue = 42;
double doubleValue = 3.14;
dos.writeInt(intValue);
dos.writeDouble(doubleValue);
} catch (IOException e) {
e.printStackTrace();
}

Example of using DataInputStream:

try (FileInputStream fis = new FileInputStream("file.dat");

DataInputStream dis = new DataInputStream(fis)) {
int intValue = dis.readInt();
double doubleValue = dis.readDouble();
// Process the read values
} catch (IOException e) {
e.printStackTrace();
}

The DataInputStream and DataOutputStream classes allow you to write and

read data in a specific format, ensuring consistency across different platforms.

These are some of the concepts and classes related to stream filters, buffered
streams, and data input/output streams in Java. They provide additional
functionalities and enhancements to the basic input/output stream operations.

Print Stream:
PrintStream is a class in Java that provides methods for printing formatted
representations of data to an output stream. It is commonly used to write text
data to the console or to a file. PrintStream extends the OutputStream class and
provides additional print and println methods for convenient printing.

JAVA 87
 Example of using PrintStream to write to console:

import java.io.PrintStream;

public class PrintStreamExample {

public static void main(String[] args) {
PrintStream ps = System.out;
ps.println("Hello, World!");
ps.printf("The value of pi is %.2f", Math.PI);
ps.close();
}
}

In this example, we create a PrintStream object ps which represents the

standard output stream. We use the println method to print a line of text to the
console, and the printf method to print formatted text, including the value of pi
with two decimal places.

Random Access File:

RandomAccessFile is a class in Java that allows random access to the contents
of a file. Unlike other stream classes, RandomAccessFile supports both reading
and writing operations at any position within the file. It provides methods for
seeking to a specific position, reading data from that position, and writing data to
that position.

Example of using RandomAccessFile to read and write data:

import java.io.IOException;
import java.io.RandomAccessFile;

public class RandomAccessFileExample {

public static void main(String[] args) {
try (RandomAccessFile file = new RandomAccessFile("data.txt", "rw")) {
// Writing data
file.writeInt(42);
file.writeDouble(3.14);

// Seeking to a specific position

file.seek(0);

// Reading data
int intValue = file.readInt();
double doubleValue = file.readDouble();

System.out.println("Read values: " + intValue + ", " + doubleValue);

JAVA 88
 } catch (IOException e) {
e.printStackTrace();
}
}
}

In this example, we create a RandomAccessFile object file with the file name
"data.txt" and mode "rw" (read-write). We write an integer value and a double
value to the file using the writeInt and writeDouble methods. Then, we seek to
the beginning of the file using the seek method. Finally, we read the values back
from the file using the readInt and readDouble methods.
RandomAccessFile provides flexibility in accessing specific parts of a file,
making it useful for scenarios where you need to read or modify data at arbitrary
positions within a file.

JDBC (Database connectivity with MS-Access, Oracle, MS-

SQL Server)
JDBC (Java Database Connectivity) is a Java API that provides a standard way
to interact with relational databases. It enables Java applications to connect to a
database, execute SQL queries, retrieve and manipulate data, and manage
database transactions. Here's an overview of JDBC and how it can be used to
connect to different databases:

1. JDBC Architecture:

DriverManager: The central class that manages the JDBC drivers. It is

responsible for establishing a connection to the database.

Connection: Represents a connection to a database. It provides

methods to create statements, manage transactions, and close the
connection.

Statement: Used to execute SQL queries or updates in the database.

ResultSet: Represents the result of a query. It allows you to retrieve and

manipulate data returned from the database.

2. Database Connectivity Steps:

Load the JDBC driver: Before connecting to a database, you need to

load the appropriate JDBC driver class using Class.forName() . Each

JAVA 89
 database vendor provides its own JDBC driver that you need to include
in your project.

Establish a connection: Use the DriverManager.getConnection() method to

establish a connection to the database by providing the database URL,
username, and password.

Execute SQL statements: Create a Statement or PreparedStatement object

from the Connection and execute SQL queries or updates using
executeQuery() or executeUpdate() methods.

Process the results: If executing a query, retrieve the results using the
ResultSet object and process the data as needed.

Close the resources: Close the ResultSet, Statement, and Connection

objects after you have finished working with them.

Example of connecting to a database and executing a query using JDBC:

import java.sql.*;

public class JDBCTest {

public static void main(String[] args) {
String jdbcUrl = "jdbc:mysql://localhost:3306/mydatabase";
String username = "myuser";
String password = "mypassword";

try (Connection conn = DriverManager.getConnection(jdbcUrl, username, pass

word);
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM users")) {

while (rs.next()) {
int id = rs.getInt("id");
String name = rs.getString("name");
System.out.println("ID: " + id + ", Name: " + name);
}

} catch (SQLException e) {
e.printStackTrace();
}
}
}

1. Database-specific Drivers:

JAVA 90
 MS-Access: To connect to an MS-Access database, you need to use the
JDBC-ODBC Bridge driver. This driver acts as a bridge between the
JDBC API and the ODBC API. You'll need to set up the ODBC data
source for your MS-Access database and use it in the JDBC URL.

Oracle: To connect to an Oracle database, you need to download and

include the Oracle JDBC driver in your project. The JDBC URL typically
includes the database host, port, service name, and
username/password.

MS-SQL Server: To connect to an MS-SQL Server database, you need

to download and include the SQL Server JDBC driver in your project.
The JDBC URL typically includes the database host, port, database
name, and username/password.

Note: The specific details of connecting to each database may vary, so refer to
the documentation and JDBC driver documentation provided by the respective
database vendor for the exact configurations and usage.

These are some of the concepts and steps involved in using JDBC for database
connectivity in Java, including connecting to different databases such as MS-
Access, Oracle, and MS-SQL Server.

Object Serialization
Object serialization in Java refers to the process of converting an object into a
stream of bytes, which can be written to a file or transmitted over a network.
Serialization allows objects to be saved or transmitted and later deserialized
back into objects. This is useful for scenarios such as persisting object state,
sending objects over a network, or storing objects in a database.

To make a class serializable, it needs to implement the Serializable interface,

which is a marker interface with no methods. By default, all of the class's non-
transient instance variables are serialized. Here's an example:

import java.io.*;

public class SerializationExample {

public static void main(String[] args) {
// Create an object to serialize
Person person = new Person("John Doe", 30);

// Serialize the object to a file

JAVA 91
 try (FileOutputStream fileOut = new FileOutputStream("person.ser");
ObjectOutputStream out = new ObjectOutputStream(fileOut)) {
out.writeObject(person);
System.out.println("Object serialized successfully.");
} catch (IOException e) {
e.printStackTrace();
}

// Deserialize the object from the file

try (FileInputStream fileIn = new FileInputStream("person.ser");
ObjectInputStream in = new ObjectInputStream(fileIn)) {
Person deserializedPerson = (Person) in.readObject();
System.out.println("Deserialized object: " + deserializedPerson);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}

class Person implements Serializable {

private String name;
private int age;

public Person(String name, int age) {

this.name = name;
this.age = age;
}

// Getters and setters

@Override
public String toString() {
return "Person{name='" + name + "', age=" + age + "}";
}
}

In this example, the Person class implements the Serializable interface, which
allows instances of the class to be serialized and deserialized. The Person object
is serialized by writing it to a file using ObjectOutputStream , and then it is
deserialized by reading from the file using ObjectInputStream . The deserialized
object is cast back to the Person type.

Sockets
Sockets in Java provide a way to establish communication channels between
two different programs running on the same machine or over a network. They
facilitate client-server communication by allowing data to be sent and received

JAVA 92
 across network connections. Java provides the Socket and ServerSocket classes
to handle network communication using sockets.

Client Socket: The Socket class represents a client-side socket that initiates
a connection to a server. It provides methods to establish a connection, send
data to the server, and receive data from the server.

Server Socket: The ServerSocket class represents a server-side socket that

listens for incoming client connections. It provides methods to accept client
connections and create individual Socket objects for each client connection.
The server can then send and receive data with the client using the Socket
object.

Here's an example of a simple client-server communication using sockets:

// Server code
import java.io.*;
import java.net.*;

public class Server {

public static void main(String[] args) {
try (ServerSocket serverSocket = new ServerSocket(1234);
Socket clientSocket = serverSocket.accept();
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), tru
e);
BufferedReader in = new BufferedReader(new InputStreamReader(clientSo
cket.getInputStream()))) {

System.out.println("Server: Client connected");

String inputLine;
while ((inputLine = in.readLine()) != null) {
System.out.println("Server: Received from client: " + inputLine);
out.println

("Server: Received your message: " + inputLine);

}
} catch (IOException e) {
e.printStackTrace();
}
}
}

// Client code
import java.io.*;
import java.net.*;

public class Client {

public static void main(String[] args) {

JAVA 93
 try (Socket socket = new Socket("localhost", 1234);
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
BufferedReader in = new BufferedReader(new InputStreamReader(socket.g
etInputStream()));
BufferedReader stdIn = new BufferedReader(new InputStreamReader(Syste
m.in))) {

String userInput;
while ((userInput = stdIn.readLine()) != null) {
out.println(userInput);
System.out.println("Client: Sent to server: " + userInput);
String response = in.readLine();
System.out.println("Client: Received from server: " + response);
}
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}

In this example, the server listens on port 1234 using a ServerSocket . When a
client connects, it accepts the connection and creates input and output streams
to communicate with the client. The server receives messages from the client,
prints them, and sends a response back.

The client creates a Socket object to connect to the server's IP address and port.
It also creates input and output streams to communicate with the server. The
client reads input from the user, sends it to the server, and displays the response
received from the server.

Development of client Server applications

1. Define the Application Protocol:

Decide on the communication protocol, such as TCP/IP, HTTP, or

WebSocket, that will be used for client-server communication. This
choice will influence the libraries and frameworks you use.

2. Implement the Server-Side Application:

Create a Java class to represent the server application.

Use the ServerSocket class from the java.net package to listen for
incoming client connections.

JAVA 94
 Accept client connections by calling the accept() method of the
ServerSocket class, which returns a Socket object representing the client

connection.

Spawn a new thread or use a thread pool to handle each client request
separately, allowing multiple clients to connect concurrently.

Receive and parse requests from clients by reading from the input
stream of the Socket object.

Perform necessary processing or interact with a database or other

external resources to handle the client request.

Generate an appropriate response and send it back to the client by

writing to the output stream of the Socket object.

3. Implement the Client-Side Application:

Create a Java class to represent the client application.

Use the Socket class from the java.net package to establish a

connection with the server by providing the server's IP address and port
number.

Send requests to the server by writing to the output stream of the Socket

object.

Wait for the server's response by reading from the input stream of the
Socket object.

Process the response received from the server and take appropriate
action based on the application logic.

4. Test and Debug:

Run both the server-side and client-side applications and verify that they
can communicate properly.

Test various scenarios, such as handling multiple client connections,

sending different types of requests, and handling error conditions.

Debug any issues or errors that arise during testing, such as incorrect
data transmission or unexpected behavior.

5. Enhance and Scale the Application:

JAVA 95
 Add additional functionality to the client and server applications as
needed.

Consider using higher-level frameworks or libraries, such as Java

Servlets or Spring Boot, to simplify development and provide additional
features.

Optimize the code for performance and scalability, ensuring efficient

resource usage and minimizing response times.

Implement proper error handling and exception management to handle

edge cases and ensure robustness.

6. Deploy and Maintain the Application:

Deploy the server-side application on a server or hosting platform that

allows for incoming client connections.

Distribute the client-side application to end-users or provide instructions

for accessing and installing it.

Monitor the application's performance, handle maintenance tasks, and

apply updates or patches as needed.

Ensure security by following best practices, such as input validation,

authentication, and secure communication protocols.

Java provides built-in classes and libraries for socket-based communication,

making it relatively straightforward to develop client-server applications.
However, depending on the complexity of your application and specific
requirements, you may consider using frameworks like Java Servlets, Spring
Boot, or Netty, which offer higher-level abstractions and additional features to
simplify client-server development.

Design of multithreaded server

Designing a multithreaded server involves creating a server application that can
handle multiple client connections concurrently using threads. Here's a basic
outline of the design:

1. Create a Server Socket:

Use the ServerSocket class from the java.net package to create a server
socket that listens for incoming client connections on a specific port.

JAVA 96
 Choose an appropriate port number for your server.

2. Accept Client Connections:

Create a loop to continuously accept client connections using the

accept() method of the ServerSocket class.

For each client connection, create a new thread or use a thread pool to
handle the client's requests separately.

3. Handle Client Requests:

For each client connection, create a new thread or task to handle the
client's requests.

Inside the thread or task, use the Socket object representing the client
connection to communicate with the client.

Read data from the input stream of the Socket to receive client requests.

Process the client's requests according to your application's logic.

Send responses back to the client by writing data to the output stream of
the Socket .

4. Manage Thread Safety:

Ensure thread safety when accessing shared resources or data

structures by using appropriate synchronization mechanisms, such as
locks or synchronized blocks/methods.

If multiple client threads need to access shared resources

simultaneously, implement thread-safe data structures or use
concurrency utilities provided by Java, such as ConcurrentHashMap or
Atomic classes.

5. Graceful Thread Termination:

Handle proper termination of client threads when clients disconnect or

the server is shutting down.

Implement a mechanism to detect client disconnections and clean up

any resources associated with the disconnected client.

Provide a way to gracefully stop the server, which includes stopping new
client connections and waiting for existing client threads to finish their

JAVA 97
 work before exiting.

6. Error Handling and Logging:

Implement proper error handling to handle exceptions that may occur

during client communication, such as network errors or invalid client
requests.

Use logging frameworks, such as Log4j or Java's built-in logging

framework, to log important events, errors, and debugging information
for troubleshooting purposes.

7. Scalability and Performance Considerations:

If your server needs to handle a large number of concurrent

connections, consider using a thread pool to limit the number of active
threads and manage resources efficiently.

Optimize your code and algorithms to minimize response times and

improve overall performance.

Consider using non-blocking I/O and asynchronous programming

models, such as Java NIO or frameworks like Netty, to handle a high
number of connections with lower resource usage.

Remember to thoroughly test your multithreaded server application to ensure it

handles multiple client connections correctly and performs well under various
scenarios. Pay attention to thread safety, synchronization, and error handling to
avoid concurrency issues and provide a reliable server experience.

Note: The implementation details of a multithreaded server can vary depending

on your specific requirements, the Java version you're using, and the
libraries/frameworks employed. The outline provided above serves as a general
guide to get started with designing a multithreaded server in Java.

Remote Method invocation

Remote Method Invocation (RMI) is a mechanism in Java that allows objects in
one Java Virtual Machine (JVM) to invoke methods on objects located in another
JVM. It enables distributed computing by providing a way for Java programs to
communicate and interact across different JVMs, even on different machines.

Here's an overview of how RMI works:

JAVA 98
 1. Define Remote Interface:

Create an interface that defines the methods that can be invoked

remotely. This interface should extend the java.rmi.Remote interface, and
each method should throw java.rmi.RemoteException .

2. Implement Remote Class:

Create a class that implements the remote interface. This class

represents the actual object that will be accessed remotely.

Extend the java.rmi.server.UnicastRemoteObject class to provide the

necessary remote object functionality.

Implement the methods defined in the remote interface.

3. Start RMI Registry:

The RMI registry acts as a lookup service for remote objects. It

maintains a registry of remote objects and their associated names.

Start the RMI registry using the rmiregistry command or

programmatically using the LocateRegistry.createRegistry() method.

4. Register Remote Object:

Register the remote object with the RMI registry using the rebind()

method of the java.rmi.Naming class.

Associate a unique name with the remote object in the registry.

5. Create Client Application:

Create a separate Java application that will act as the client.

Obtain a reference to the remote object from the RMI registry using the
lookup() method of the java.rmi.Naming class.

6. Invoke Remote Methods:

Use the obtained reference to the remote object to invoke methods as if

it were a local object.

The RMI framework handles the underlying communication and

marshalling of method arguments and return values between the client
and server JVMs.

JAVA 99
 7. Handle Exceptions:

Both the remote interface and the remote object implementation should
throw java.rmi.RemoteException to handle communication-related
exceptions that may occur during remote method invocation.

8. Security Considerations:

Configure security settings to ensure secure communication between

the client and server JVMs.

Provide appropriate access control and authentication mechanisms to

protect the integrity and confidentiality of the remote method invocations.

RMI simplifies distributed computing in Java by abstracting the complexity of

network communication and providing a transparent way to invoke methods on
remote objects. It enables the development of distributed applications where
objects in different JVMs can interact seamlessly.

Note: RMI has been part of the Java platform for many years, but there are
alternative technologies available today for distributed computing in Java, such
as Java Remote Method Invocation over Internet Inter-ORB Protocol (RMI-IIOP),
Java Message Service (JMS), and web services.

Java Native interfaces and Development of a JNI based

application
Java Native Interface (JNI) is a programming framework that allows Java code to
call native code written in languages like C or C++. JNI enables developers to
integrate existing native code libraries or take advantage of platform-specific
functionality in their Java applications. Here's an overview of JNI and the
development process of a JNI-based application:

1. Understanding JNI Basics:

JNI provides a set of functions and rules for communication between

Java and native code.

Java classes can define native methods, which are declared using the
native keyword and implemented in native code.

The Java Native Interface allows for passing data and invoking native
functions from Java code and vice versa.

JAVA 100
 2. Write Native Code:

Create the native code implementation in a language like C or C++.

The native code should match the function signatures declared in the
native methods of the corresponding Java classes.

Include the necessary header files, such as jni.h , which provide the
JNI function prototypes and macros.

3. Create JNI Wrapper:

Create a Java class that serves as a wrapper for the native code. This
class will contain the native method declarations.

Use the native keyword to declare the methods that will be

implemented in the native code.

Load the native library that contains the native code using the
System.loadLibrary() method.

4. Generate Header File:

Use the Java javac command with the h option to generate the C/C++
header file for the Java class that contains native method declarations.

This header file will be used in the native code implementation.

5. Implement Native Methods:

Implement the native methods in the native code file (.c or .cpp) using
the function signatures defined in the generated header file.

Use the JNI function calls to interact with Java objects, invoke Java
methods, get/set field values, and handle exceptions.

JNI provides functions like JNIEnv for accessing Java environment,

for obtaining class references, jmethodID for identifying Java
jclass

methods, and various other utility functions for data conversion.

6. Compile and Link:

Compile the native code file (.c or .cpp) using a C/C++ compiler and
generate a shared library file (e.g., a DLL on Windows or a shared
object on Unix-like systems).

JAVA 101
 Ensure that the necessary JNI library files are included during
compilation and linking.

7. Load and Run the JNI-Based Application:

Place the generated shared library file in a location accessible to the

Java application.

Load the native library using the System.loadLibrary() method in the Java
code before invoking the native methods.

The JVM will load the shared library and make the native methods
available for invocation.

8. Test and Debug:

Run the Java application and test the functionality of the JNI-based
code.

Debug any issues that arise during execution, such as incorrect data
handling or compatibility problems between Java and native code.

9. Manage Memory and Resource Cleanup:

JNI requires manual memory management for objects and resources

allocated in native code.

Use JNI functions like NewObject , NewArray , and NewGlobalRef to allocate

memory in native code and DeleteLocalRef or DeleteGlobalRef to release
the allocated memory.

10. Performance Considerations:

Optimize the native code for performance, especially if it involves

computationally intensive tasks or time-critical operations.

Take advantage of native code optimizations, such as leveraging

platform-specific libraries or utilizing low-level programming techniques.

JNI allows you to leverage existing native code libraries or access platform-
specific functionality from your Java applications. It provides a bridge between
Java and native code, enabling you to combine the portability of Java with the
power and

flexibility of native languages.

JAVA 102
 Note: When working with JNI, it's important to exercise caution as it involves
direct interaction with native code, which can introduce potential security risks
and compatibility issues.

Java Collection API Interfaces

1. Collection Interface:

Root interface of the Collection API hierarchy.

Defines common methods for all collections.

2. List Interface:

Represents an ordered collection with duplicate elements.

Key implementations: ArrayList, LinkedList.

3. Set Interface:

Represents a collection with unique elements (no duplicates).

Key implementations: HashSet, LinkedHashSet.

4. Queue Interface:

Represents a collection for holding elements prior to processing.

Follows FIFO or priority-based order.

Key implementations: LinkedList, PriorityQueue.

5. Map Interface:

Represents a collection of key-value pairs.

Key implementations: HashMap, LinkedHashMap, TreeMap.

Other Classes and Concepts:

1. Vector Class:

Dynamic array-like data structure, similar to ArrayList.

Synchronized (thread-safe).

Methods for element manipulation and access.

2. Stack Class:

Subclass of Vector, implements a LIFO stack.

JAVA 103
 Methods for stack operations like push, pop, and peek.

3. Hashtable Class:

Implements a hashtable data structure for key-value pairs.

Synchronized (thread-safe).

Methods for element manipulation and access.

4. Enumerations:

Interface for iterating over a collection of elements sequentially.

5. Set Interface:

Represents a collection with unique elements (no duplicates).

6. List Interface:

Represents an ordered collection with duplicate elements.

7. Map Interface:

Represents a collection of key-value pairs.

8. Iterators:

Objects for iterating over elements in a collection.

Methods like hasNext and next for sequential iteration.

These concepts and classes form the foundation for working with collections in
Java, allowing you to store, manipulate, and iterate over groups of elements
efficiently.

JAVA 104