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