UNIT-2

Definition of a Constructor

1. In Java, a constructor is a special block of code that is similar to a method but is used
specifically to initialize a newly created object.
2. It is called automatically when an instance of a class is created using the new
keyword.

Key Characteristics:

 It must have the exact same name as the class.

 It cannot have a return type (not even void).
 It is called only once per object creation.

Types of Constructors in Java

1. Default Constructor

1. If you do not define any constructor in your class, the Java compiler automatically
inserts a default constructor for you.
2. It initializes member variables with default values (e.g., 0 for integers, null for
objects).

2. No-Argument Constructor

1. This is a constructor explicitly defined by the programmer that accepts no parameters.

2. It is often used to set initial values for object attributes.

Code Example:

class Student {
String name;

// No-argument constructor
Student() {
name = "Unknown";
[Link]("No-argument constructor called.");
}
}

public class Main {

public static void main(String[] args) {
Student s1 = new Student(); // Output: No-argument constructor
called.
}
}
3. Parameterized Constructor

1. A constructor that has a specific list of parameters is known as a parameterized

constructor.
2. It is used to provide different values to distinct objects at the time of their creation.

Code Example:

class Student {
String name;
int age;

// Parameterized constructor
Student(String n, int a) {
name = n;
age = a;
}

void display() {
[Link]("Name: " + name + ", Age: " + age);
}
}

public class Main {

public static void main(String[] args) {
// Passing values to the constructor
Student s2 = new Student("Alice", 20);
[Link](); // Output: Name: Alice, Age: 20
}
}

The this Keyword in Java

1. In Java, this is a reference variable that refers to the current object (the instance of
the class in which the code is currently executing).
2. It is most commonly used inside constructors and methods.

Applications of this Keyword

1. To Distinguish Instance Variables from Parameters

When a constructor or method has parameters with the same name as the class's instance
variables (fields), the parameter "shadows" the field. The this keyword is used to specify
that you are referring to the instance variable rather than the local parameter.
Code Example:

class Employee {
String name; // Instance variable

// Parameter 'name' has the same name as the instance variable

Employee(String name) {
[Link] = name; // '[Link]' refers to the instance variable
}

void display() {
[Link]("Employee Name: " + [Link]);
}
}

2. To Invoke the Current Class Constructor (Constructor Chaining)

You can use this() to call one constructor from another constructor within the same class.
This is useful for reducing code duplication when you have multiple constructors
(overloading).

 Note: this() must be the first statement in the constructor.

Code Example:

class Box {
int length, width;

// No-arg constructor calling the parameterized constructor

Box() {
this(10, 10); // Calls the constructor below with default values
}

Box(int length, int width) {

[Link] = length;
[Link] = width;
}
}

3. To Pass the Current Object as a Parameter

Sometimes a method needs to pass the entire object it is working on to another method. You
can use this as the argument.

Code Example:

class Calculator {
void printTotal(Calculator obj) {
[Link]("Processing object...");
}

void execute() {
printTotal(this); // Passing the current instance to another method
}
}
Summary of Key Uses

 [Link]: Refers to the current class instance variable.

 [Link](): Invokes the current class method (implicitly done, but can be
explicit).
 this(): Invokes the current class constructor.

What are Command Line Arguments?

1. Command line arguments are parameters that are passed to a Java program when it
is executed.
2. These arguments allow you to provide input to the program from the console or
terminal without modifying the source code.

How They Work in Java

In Java, command line arguments are stored as String objects in a String array, which is
passed to the main method of your class.

The Main Method Signature:

public static void main(String[] args)

 String[] args: This is an array of strings. Every word or value you type after the
program name in the command line is stored in this array.

Application and Code Example

If you want to create a program that greets a user by the name they provide at the command
line:

Code Example:

public class Greet {

public static void main(String[] args) {
// Checking if an argument was actually provided
if ([Link] > 0) {
[Link]("Hello, " + args + "!");
} else {
[Link]("No name was provided.");
}
}
}
How to run it:

1. Compile: javac [Link]

2. Execute with arguments: java Greet Rahul
o Output: Hello, Rahul!

Key Characteristics:

 Array indexing: The first argument is stored at args, the second at args, and so on.
 Data Type: All arguments are passed as Strings. If you need to use them as numbers
(like integers), you must convert them using methods like [Link](args).
 Count: You can find out how many arguments were passed using [Link].

What are Varargs?

1. Varargs (Variable-Length Arguments) is a feature in Java that allows a method to

accept a variable number of arguments of the same type.
2. It was introduced to simplify method calls when the exact number of inputs is not
known beforehand.

Syntax and Key Rules

To declare a varargs parameter, you follow the data type with three dots (...).

Syntax Example:

public void printNumbers(int... numbers) {

// Inside the method, 'numbers' is treated as an array (int[])
}

Important Rules:

 Only one varargs parameter: A method can have only one variable-length
argument.
 Positioning: The varargs parameter must be the last parameter in the method
signature. For example, void method(String s, int... i) is correct, but void
method(int... i, String s) is invalid.
Application and Code Example

A common application of varargs is creating a utility method that can process any number of
inputs, such as calculating a sum or formatting a string.

Code Example:

public class Calculator {

// Method that can take any number of integer arguments
static void displaySum(String message, int... values) {
int total = 0;
for (int num : values) {
total += num;
}
[Link](message + ": " + total);
}

public static void main(String[] args) {

// Calling with different numbers of arguments
displaySum("Sum of two", 10, 20);
displaySum("Sum of five", 1, 2, 3, 4, 5);
displaySum("Sum of zero"); // Passing no values for varargs is also
valid
}
}

Benefits of Using Varargs

 Reduces Method Overloading: You don't need to write multiple versions of the
same method to handle different numbers of arguments.
 Cleaner Syntax: It makes the method call look simpler than passing an explicit array
(e.g., sum(1, 2) vs. sum(new int[]{1, 2})).

Visibility Control in Java (Access Modifiers):

1. Visibility control, or Access Modifiers, are keywords used to set the accessibility
(visibility) of classes, constructors, methods, and variables.
2. They define which parts of a program can "see" or interact with a specific member.
3. There are four levels of visibility in Java:

1. private (Most Restrictive)

 Scope: The member is accessible only within the same class.

 Use Case: This is the foundation of Encapsulation. It is used to hide sensitive data
(like fields) from outside interference.
 Example: private int age;
2. Default (No Keyword)

 Scope: The member is accessible only within the same package.

 Use Case: When you don't specify any modifier, it is "package-private." It is used for
internal logic that should be shared within a package but hidden from the rest of the
application.

3. protected

 Scope: The member is accessible within the same package and by subclasses (even
if they are in different packages).
 Use Case: This is used in Inheritance when you want a child class to have access to
a parent's member but still keep it hidden from the general public.

4. public (Least Restrictive)

 Scope: The member is accessible from any other class in any package.
 Use Case: Used for methods and classes that are intended to be the "entry points" or
API of your application.
 Example: public void start() { ... }

Visibility Summary Table

Modifier Class Package Subclass World

public Yes Yes Yes Yes
protected Yes Yes Yes No
Default Yes Yes No No
private Yes No No No

Introduction to Array

1. An Array in Java is a container object that holds a fixed number of values of a single
type (homogeneous data).
2. It is an indexed-based data structure where the first element is stored at index 0.

Declaration, Creation, and Initialization

1. Declaration: This tells the compiler the variable name and the type of data it will
hold.
o int[] myArray; (Recommended)
o int myArray[];
2. Creating an Array: This allocates memory for the array using the new keyword.
o myArray = new int; (Creates an array of size 5)
3. Initialization: This assigns values to the array elements.
o Manual: myArray = 10;
o Inline (Declaration + Initialization): int[] myArray = {10, 20, 30, 40,
50};
Array Types in Java

 Single-Dimensional Array: A simple list of variables.

o Example: int[] marks = new int;
 Multi-Dimensional Array: An "array of arrays." The most common is the 2D array
(like a matrix or table).
o Example: int[][] matrix = new int; (2 rows, 3 columns)

Code Example:
public class ArrayExample {
public static void main(String[] args) {
// Declaration and Initialization
int[] numbers = {10, 20, 30, 40};

// Accessing elements and Application

[Link]("First Element: " + numbers);

// Using a loop to traverse the array

[Link]("All Elements: ");
for (int i = 0; i < [Link]; i++) {
[Link](numbers[i] + " ");
}
}
}

Advantages and Disadvantages

Advantages Disadvantages
Code Optimization: Allows us to retrieve or sort Fixed Size: Once created, you cannot change
data efficiently. the size of an array at runtime.
Random Access: We can get any data located at Homogeneous Data: It can only store one type
an index position instantly. of data (e.g., only integers).
Memory Efficiency: Better memory
Memory Wastage: If you declare a large size
management for storing multiple elements of the
but use only a few elements, memory is wasted.
same type.

Application

Arrays are used whenever we need to store multiple items of the same type, such as a list of
student names, marks in different subjects, or coordinates in a game.
Introduction to String

1. In Java, a String is an object that represents a sequence of characters.

2. Unlike primitive data types (like int or char), a String is a class in the [Link]
package.
3. One of the most important features of a String is that it is immutable, meaning once a
String object is created, its value cannot be changed.

Declaration, Creation, and Initialization

There are two primary ways to create and initialize a String object in Java:

1. Using String Literal:

o Syntax: String str = "Hello";
o Functionality: Java uses a special memory area called the String Constant
Pool. If the string "Hello" already exists in the pool, the variable str will
point to the existing instance rather than creating a new one, which saves
memory.
2. Using the new Keyword:
o Syntax: String str = new String("Hello");
o Functionality: This explicitly creates a new object in the heap memory, even
if "Hello" already exists in the String Pool.

String Types/Categories

While the String class is the most common, Java provides other "types" of character
sequences for different needs:

 String: Immutable (cannot be changed).

 StringBuilder: Mutable (can be changed) and faster, but not thread-safe.
 StringBuffer: Mutable and thread-safe (used in multi-threaded environments).

Code Example
public class StringDemo {
public static void main(String[] args) {
// Declaration and Initialization
String greeting = "Welcome to Java";

// Using String methods (Functionality)

[Link]("Length: " + [Link]()); // Returns 15
[Link]("Uppercase: " + [Link]());
[Link]("Character at index 0: " + [Link](0));
// Returns 'W'

// Concatenation
String s1 = "Hello ";
String s2 = "World";
String s3 = [Link](s2); // Combines strings
[Link](s3);
}
}
Advantages and Disadvantages

Advantages Disadvantages
Memory Overhead: Every time you modify a
Security: Because Strings are immutable,
String (e.g., adding a character), a completely
they are safe to use as keys in maps and for
new object is created, which can be slow and
networking/database connections.
memory-intensive.
String Pool: Efficient memory Not suitable for heavy manipulation: For
management by sharing identical string frequent changes (like in a loop), you must use
literals. StringBuilder instead.
Thread-Safety: Immutability
No Subclassing: The String class is final, so
automatically makes Strings thread-safe
you cannot extend it to add custom behavior.
without needing synchronization.

Application

Strings are used in almost every Java application, from storing user input and passwords to
processing data from files or APIs and displaying text in user interfaces.

Introduction to String Class

1. In Java, a String is an object that represents a sequence of characters.

2. It is not a primitive data type (like int or char) but a class defined in the [Link]
package.
3. A key feature of the String class is that it is immutable, meaning once a String object
is created, its data cannot be modified.

Declaration, Creation, and Initialization

There are two ways to create a String object:

1. String Literal:
o Syntax: String str = "Java";
o Functionality: This is the most efficient way. Java uses a String Constant
Pool to store literals. If the string "Java" already exists in the pool, the variable
points to that existing object instead of creating a new one.
2. Using new Keyword:
o Syntax: String str = new String("Java");
o Functionality: This always creates a new object in the heap memory, even if
"Java" is already present in the String Pool.

String Types/Classes in Java

While the String class is standard, Java offers other classes for different functionalities:

 String: Immutable; best for fixed text.

 StringBuilder: Mutable (can be changed); faster for heavy modifications but not
thread-safe.
 StringBuffer: Mutable and thread-safe; used in multi-threaded environments.

Code Example and Functionality

public class StringUsage {
public static void main(String[] args) {
// Initialization
String text = "Learning Java";

// Common Functionalities (Methods)

[Link]("Length: " + [Link]()); // Returns 13
[Link]("At index 0: " + [Link](0)); // Returns 'L'
[Link]("Contains 'Java': " + [Link]("Java")); //
Returns true

// Immutability Check
String upper = [Link](); // Creates a NEW string
[Link]("Original: " + text); // Still "Learning Java"
[Link]("Modified: " + upper); // "LEARNING JAVA"
}
}

Advantages and Disadvantages

Advantages Disadvantages
Performance Overhead: Since Strings cannot
Security: Immutability makes Strings safe
be changed, every modification (like
for storing sensitive data like passwords or
concatenation) creates a new object, consuming
URLs.
memory.
Not suitable for heavy loops: Using + in a loop
Caching (String Pool): Saves memory by
to build a string is very slow; you must use
reusing identical string literals.
StringBuilder instead.
Thread-Safety: Because they are
immutable, they can be shared across No Subclassing: The class is final, so it cannot
multiple threads without synchronization be inherited.
issues.

Application

Strings are fundamental to almost all Java applications. They are used for user input/output,
storing data from databases, network communication, and creating dynamic content in web
applications.

Introduction to StringBuffer
 1. In Java, StringBuffer is a class used to create mutable (modifiable) strings.
2. Unlike the String class, which creates fixed-length objects that cannot be changed, a
StringBuffer can grow or shrink in size and its content can be modified without
creating a new object every time.
3. It is thread-safe, meaning multiple threads cannot access it simultaneously, making it
safe for use in multi-threaded environments.

Declaration, Creation, and Initialization

Unlike Strings, StringBuffer objects cannot be created using literals. They must be
created using the new keyword.

1. Default Creation:
o StringBuffer sb = new StringBuffer();
Functionality: Creates an empty string buffer with an initial capacity of 16
o
characters.
2. With Initial String:
o StringBuffer sb = new StringBuffer("Hello");
Functionality: Creates a buffer containing the specified string.
o
3. With Specific Capacity:
o StringBuffer sb = new StringBuffer(50);
o Functionality: Creates an empty buffer with a defined initial capacity of 50.

Key Functionality (Methods)

 append(String s): Adds text to the end of the existing string.

 insert(int offset, String s): Inserts text at a specific position.
 replace(int start, int end, String s): Replaces a sequence of characters
with a new string.
 reverse(): Reverses the characters in the buffer.
 delete(int start, int end): Removes a section of the string.

Code Example
public class BufferDemo {
public static void main(String[] args) {
// Initialization
StringBuffer sb = new StringBuffer("Hello");

// Modifications (Mutable)
[Link](" Java"); // Original object is modified
[Link](5, " World");

[Link]("Modified String: " + sb); // Output: Hello

World Java

[Link]();
[Link]("Reversed: " + sb); // Output: avaJ dlroW olleH
}
}

Advantages and Disadvantages

Advantages Disadvantages
Mutability: You can change the string Performance: Because it is thread-safe
content (append, delete, insert) without (synchronized), it is slightly slower than
creating multiple objects, which saves StringBuilder in single-threaded
memory. environments.
Efficiency: Highly efficient for heavy string Memory: It allocates extra capacity (default
manipulations (like inside a loop). 16) even if not immediately needed.
Thread-Safety: Safe to use when multiple Syntax: It is more verbose than using simple
threads are modifying the same string. String literals.

Application

1. StringBuffer is primarily used in multi-threaded Java applications where a string

needs to be modified frequently by different parts of the program.
2. It is also used in legacy code where thread safety was a primary concern before
StringBuilder was introduced.

UNIT-III
Concept of Inheritance

1. Inheritance is a fundamental concept in Object-Oriented Programming (OOP) that

allows one class (the Child or Subclass) to acquire the properties (fields) and
behaviors (methods) of another class (the Parent or Superclass).
2. In Java, this is achieved using the extends keyword.

 Goal: To promote code reusability and establish a "IS-A" relationship (e.g., a Car is
a Vehicle).

Types of Inheritance in Java

1. Single Inheritance

In single inheritance, a subclass inherits from only one superclass.

 Application: Used for basic specialization of a class.

 Code Example:

class Animal {
void eat() { [Link]("Eating..."); }
}
class Dog extends Animal {
void bark() { [Link]("Barking..."); }
}
// Dog inherits eat() from Animal
2. Multilevel Inheritance

This involves a chain of inheritance where a subclass acts as a parent for another subclass.

 Application: Used for multi-level classifications (e.g., Animal -> Mammal -> Dog).
 Code Example:

class Animal { void eat() { [Link]("Eating..."); } }

class Dog extends Animal { void bark() { [Link]("Barking...");
} }
class Puppy extends Dog { void weep() { [Link]("Weeping..."); }
}
// Puppy has access to eat() and bark()

3. Hierarchical Inheritance

One parent class is inherited by multiple subclasses.

 Application: Used when multiple entities share a common base but have different
specific behaviors (e.g., a Shape class inherited by Circle, Square, and Triangle).
 Code Example:

class Animal { void eat() { [Link]("Eating..."); } }

class Dog extends Animal { void bark() { [Link]("Barking...");
} }
class Cat extends Animal { void meow() { [Link]("Meowing...");
} }
// Both Dog and Cat can eat(), but they have different sounds.

4. Multiple Inheritance (Through Interfaces Only)

Java does not support multiple inheritance with classes to avoid the "Diamond Problem"
(ambiguity). However, a class can implement multiple Interfaces.

 Application: Used to combine different sets of behaviors from unrelated sources.

 Code Example:

interface Printable { void print(); }

interface Showable { void show(); }
class Document implements Printable, Showable {
public void print() { [Link]("Printing..."); }
public void show() { [Link]("Showing..."); }
}

5. Hybrid Inheritance

A combination of two or more types of inheritance. Since Java doesn't support multiple
inheritance with classes, hybrid inheritance is also only possible through Interfaces.

Advantages and Disadvantages

Feature Description
You can use the code of a parent class without rewriting it in
Advantage: Reusability
child classes.
It allows for Method Overriding, which is essential for
Advantage: Polymorphism
runtime polymorphism.
Disadvantage: Tight The child class is closely tied to the parent; if the parent class
Coupling changes, it may break the child class.
Inherited variables that are not used by the child class still
Disadvantage: Memory
occupy memory.

The provided source material, "Architectural Blueprints: The Java Constructor Explained,"
focuses exclusively on explaining constructors and does not contain any information
regarding Interfaces in Java. The following explanation is based on general Java
programming knowledge and is not derived from your sources; therefore, you may want to
independently verify this information.

Introduction to Interface

1. An Interface in Java is a reference type, similar to a class, that can contain only
constants, method signatures, default methods, static methods, and nested types.
2. It is a blueprint of a class that specifies what a class must do, but not how it does it.
3. It is the primary way to achieve 100% abstraction and multiple inheritance in Java.

Declaration and Implementation

1. Declaration: An interface is declared using the interface keyword.

o Syntax: interface Drawable { void draw(); }
2. Implementation: A class uses the implements keyword to provide the concrete
implementation of the methods defined in the interface.
o Syntax: class Circle implements Drawable { public void draw() {
... } }

Key Functionality (Rules)

 Abstract Methods: By default, all methods in an interface are public and abstract
(you don't need to write these keywords).
 Constants: All variables declared in an interface are implicitly public, static, and
final.
 No Instantiation: You cannot create an object of an interface (e.g., new Drawable()
is invalid).
 Multiple Implementation: A single class can implement multiple interfaces at the
same time.

Code Example
// Interface definition
interface Animal {
void sound(); // Abstract method
}

// Class implementing the interface

class Cat implements Animal {
public void sound() {
[Link]("Meow");
}
}

public class Main {

public static void main(String[] args) {
Animal myCat = new Cat(); // Interface reference to a class object
[Link](); // Output: Meow
}
}

Advantages and Disadvantages

Advantages Disadvantages
Total Abstraction: It hides the implementation Complexity: Adding too many interfaces
details and only shows the functionality to the can make the code harder to follow and
user. maintain.
Versioning Issues: If you add a new
Multiple Inheritance: It allows a class to inherit
method to an interface, you must update
behaviors from multiple sources, which is not
every single class that implements it
possible with classes.
(unless you use default methods).
Loose Coupling: It reduces the dependency No State: You cannot store the state of an
between classes, making the system more object (no instance variables) in an
modular and flexible. interface.

Application

1. Interfaces are widely used in Java for defining contracts. For example, the List
interface defines how a list should behave, and classes like ArrayList or LinkedList
provide the specific logic.
2. They are also essential in API development, design patterns, and plugin-based
architectures.
Implementation of an Interface:

1. As discussed previously, an interface defines a "contract" or a blueprint.

2. A class implements an interface by providing the actual code (logic) for the methods
declared in that interface using the implements keyword.

 Rule: A class that implements an interface must provide a concrete implementation

for all of its abstract methods, or the class itself must be declared as abstract.
 Multiple Implementation: A single class can implement multiple interfaces,
separated by commas.

Code Example:

interface Printer {
void print(); // Abstract method
}

// Class implementing the interface

class LaserPrinter implements Printer {
public void print() {
[Link]("Laser Printer is printing...");
}
}

Extended Interface (Interface Inheritance)

1. Just as a class can inherit from another class, an interface can inherit from another
interface.
2. This is done using the extends keyword.
3. This allows you to build a hierarchy of interfaces, adding more specific functionality
to a base interface.

 Key Difference: A class implements an interface, but an interface extends another

interface.
 Multiple Inheritance: Unlike classes, an interface can extend multiple interfaces at
once.
Code Example:

interface Animal {
void eat();
}

// Extended Interface
interface Pet extends Animal {
void play();
}

// A class implementing 'Pet' must now implement BOTH 'eat' and 'play'
class Dog implements Pet {
public void eat() {
[Link]("Dog is eating.");
}
public void play() {
[Link]("Dog is playing.");
}
}

Summary of Differences

Feature Implementation (implements) Extension (extends)

Participants Between a Class and an Interface. Between two Interfaces (or two Classes).
To provide the logic for the To inherit and expand the method
Purpose
methods. signatures.
Result Creates a concrete object. Creates a more specialized blueprint.

Application

 Implementation: Used to enforce a specific behavior across unrelated classes (e.g.,

both a User and a Product might implement Searchable).
 Extended Interface: Used to create more specific versions of a general contract
without breaking existing code. For example, the Java Collection interface is
extended by List, Set, and Queue.

Introduction to Method Overloading and Overriding

Both overloading and overriding are fundamental concepts in Java that allow for
Polymorphism (one name, many forms).

1. Method Overloading: This is Compile-time Polymorphism. It occurs when

multiple methods in the same class have the same name but different parameter
lists (different number, type, or order of arguments).
2. Method Overriding: This is Runtime Polymorphism. It occurs when a subclass
provides a specific implementation for a method that is already defined in its
superclass. The method signature (name and parameters) must be identical.

Declaration and Key Rules

Feature Method Overloading Method Overriding

Class Occurs within the same class. Occurs between Superclass and Subclass.
Parameters Must be different. Must be the same.
Return Type Can be different. Must be the same (or covariant).
Binding Static Binding (at compile time). Dynamic Binding (at runtime).
Keyword None required. Often uses the @Override annotation.

Code Example
class Calculator {
// METHOD OVERLOADING (Same name, different parameters)
int add(int a, int b) { return a + b; }
int add(int a, int b, int c) { return a + b + c; }
}

class Animal {
// METHOD OVERRIDING (Parent class method)
void sound() { [Link]("Animal makes a sound"); }
}

class Dog extends Animal {

// Overriding the parent's method
@Override
void sound() { [Link]("Dog barks"); }
}

Advantages and Disadvantages

Concept Advantages Disadvantages
Readability: Users don't have to
Confusion: Overusing it with too many
remember different names for similar
Overloading similar signatures can make the code
actions (e.g., printInt,
hard to debug.
printString).
Tight Coupling: The child class
Flexibility: Allows a child class to
depends on the parent’s method
Overriding define its own specific behavior while
structure; changes in the parent can
keeping the same interface.
break the child.

Application

 Overloading: Widely used in Java’s built-in libraries, such as

[Link](), which is overloaded to accept Strings, integers, booleans,
etc.
 Overriding: Essential for Inheritance and Interfaces. It allows you to write generic
code that works with a parent class reference but executes the specific logic of the
child object (e.g., a Shape list containing Circle and Square objects).

Introduction to Packages
 1. A Package in Java is a mechanism used to group related classes, interfaces, and
sub-packages.
2. It acts like a folder in a computer directory, helping to organize code and prevent
"naming conflicts" (where two classes have the same name).

Types of Packages

1. Built-in Packages: These are provided by the Java API.

o Examples: [Link] (fundamental classes), [Link] (utility classes like
Scanner), and [Link] (input/output).
2. User-defined Packages: These are created by the programmer to organize their own
project's code.

Naming and Creating a Package

 Naming Convention: By convention, package names are written in all lowercase to

avoid conflicts with class names. Companies usually use their reversed Internet
domain name to ensure uniqueness (e.g., [Link]).
 Creating: To create a package, you use the package keyword at the very top of your
Java source file (before any imports).
o Syntax: package mypack;

Accessing and Using a Package (Import Statement)

There are three main ways to access a class from another package:

1. Using import [Link];: This imports only a specific class.

o Example: import [Link];
2. Using import package.*;: This imports all classes within a specific package (but
not sub-packages).
o Example: import [Link].*;
3. Using Fully Qualified Name: You don't use an import statement; instead, you type
the full path every time you use the class.
o Example: [Link] sc = new
[Link]([Link]);

Code Example
File 1: [Link] (Inside a package)

package [Link]; // Creating the package

public class Calculator {

public void add(int a, int b) {
[Link]("Sum: " + (a + b));
}
}

File 2: [Link] (Using the package)

import [Link]; // Importing the class

public class Main {

public static void main(String[] args) {
Calculator obj = new Calculator();
[Link](10, 5);
}
}

Advantages and Disadvantages

Advantages Disadvantages
Categorization: Large projects become File Structure Dependency: The package name
easier to navigate by grouping similar must match the folder structure on the disk,
classes together. which can be rigid.
Access Limitations: If a class is not marked
Naming Conflict Resolution: Two classes
public, it cannot be accessed outside its
can have the same name (e.g., Date) as long
package, which can lead to visibility issues if
as they are in different packages.
not planned.
Access Protection: Packages provide a Overhead: Importing entire packages (.*) can
level of visibility control (default/package- slightly increase compilation time (though not
private access). runtime performance).

Application

1. Packages are essential for modular programming and are used in every professional
Java application.
2. They allow developers to build reusable libraries and frameworks (like Spring or
Hibernate) that can be easily imported into other projects without clashing with the
user's existing code.
The Import Statement in Java

The import statement is a keyword used to bring classes, interfaces, or entire packages into
the current source file. This allows you to use those classes in your code without having to
type their "fully qualified names" (the full package path) every time.

Declaration and Usage

 Placement: The import statement must be placed at the top of your Java file, after
the package declaration but before the class definition.
 Syntax:
o To import a single class: import [Link];
o To import an entire package: import [Link].*;

Types of Import Statements

1. Specific Class Import: Imports only the specified class. This is generally preferred as
it makes the code's dependencies clear.
o Example: import [Link];
2. Wildcard Import: Uses the asterisk (*) to import all classes within a specific
package. It does not import classes in sub-packages.
o Example: import [Link].*;
3. Static Import: Introduced in Java 5, this allows you to access static members (fields
and methods) of a class directly without qualifying them with the class name.
o Example: import static [Link]; (allows you to call
sqrt(25) instead of [Link](25)).

Code Example
package [Link]; // Package declaration first

import [Link]; // Importing specific class

import [Link];

public class Test {

public static void main(String[] args) {
Scanner sc = new Scanner([Link]); // Accessible because of
import
Date now = new Date();
[Link]("Current Date: " + now);
}
}

Advantages and Disadvantages

Advantages Disadvantages
Naming Conflicts: If two different packages contain
Code Readability: It keeps the code
a class with the same name (e.g., [Link]
clean by allowing the use of short class
and [Link]), importing both will cause a
names rather than full package paths.
compiler error.
Development Speed: It is faster to Ambiguity with Wildcards: Using .* can
write List than [Link] sometimes make it unclear which specific classes a
repeatedly. file depends on.

Functionality Note

It is important to remember that the [Link] package (which includes classes like String,
System, and Integer) is automatically imported by the Java compiler into every program.
You never need an explicit import statement for classes in that package.
 UNIT-IV

Introduction to Errors in Java

1. In Java, an error or exception is an issue that prevents the program from executing as
intended.
2. These are generally categorized into three main types:
 Compile-time errors,
 Runtime errors,
 Logical errors.

1. Compile-Time Errors (Syntax Errors)

These errors occur while you are writing or compiling the code. The Java compiler (javac)
detects these issues and prevents the creation of a .class file until they are fixed.

 Cause: Violating the rules of the Java language (syntax).

 Examples: Missing a semicolon (;), using an undeclared variable, or mismatching
brackets {}.

2. Runtime Errors (Exceptions)

These errors occur after the code has successfully compiled, while the program is actually
running. They typically cause the program to crash or "terminate abnormally."

 Cause: Invalid operations during execution that the compiler couldn't predict.
 Examples: Dividing a number by zero (ArithmeticException) or trying to access
an array index that doesn't exist (ArrayIndexOutOfBoundsException).

Difference Between Compile-Time and Runtime Errors

Feature Compile-Time Error Runtime Error

Detected by the Compiler before Detected by the JVM (Java Virtual
Detection
execution. Machine) during execution.
The program starts running but crashes
Prevention The program will not run at all.
later.
Syntax errors, type mismatches, missing Logical flaws, illegal operations,
Cause
files. memory issues.
Easy to find because the compiler gives Harder to find; requires debugging or
Fixing
the line number and error message. "Exception Handling" (try-catch).
Code Examples

Example: Compile-Time Error

public class Test {

public static void main(String[] args) {
int x = 10 // Error: Missing semicolon
[Link](y); // Error: Variable 'y' is not defined
}
}

Example: Runtime Error

public class Test {

public static void main(String[] args) {
int a = 10;
int b = 0;
// This compiles perfectly, but crashes when run
int result = a / b; // Throws ArithmeticException: / by zero
[Link](result);
}
}

3. Logical Errors

These are the most difficult to find because the program compiles and runs without
crashing, but it produces the wrong output.

 Example: Using a - b when you meant to use a + b.

What is an Exception in Java?

1. An Exception is an unwanted or unexpected event that occurs during the execution of

a program (at runtime) and disrupts the normal flow of instructions.
2. Java provides a robust framework to handle these errors so the program doesn't crash
abruptly.

1. Try and Catch Statement

The try block contains the code that might throw an exception, while the catch block
handles that exception if it occurs.

Syntax:

try {
// Code that may throw an exception
} catch (ExceptionType e) {
// Code to handle the exception
}
Code Example:

public class TryCatchExample {

public static void main(String[] args) {
try {
int data = 100 / 0; // Throws ArithmeticException
} catch (ArithmeticException e) {
[Link]("Error: Cannot divide by zero.");
}
[Link]("Rest of the code continues...");
}
}

2. Nested Try Statement

1. A try block can be placed inside another try block.

2. This is used when different parts of a block might throw different exceptions, and you
want to handle them specifically.

Code Example:

try {
try {
int[] arr = new int;
arr = 50; // Inner exception
} catch (ArrayIndexOutOfBoundsException e) {
[Link]("Inner Catch: Array index error.");
}
int x = 10 / 0; // Outer exception
} catch (ArithmeticException e) {
[Link]("Outer Catch: Arithmetic error.");
}

3. Finally Statement

1. The finally block is used to execute important code such as closing a database
connection or a file stream.
2. It always executes, whether an exception is handled or not.

Code Example:

try {
int data = 25 / 5;
} catch (NullPointerException e) {
[Link](e);
} finally {
[Link]("Finally block: This always runs.");
}
4. Throws Keyword

The throws keyword is used in a method signature to declare that the method might throw a
"Checked Exception." It "passes the buck" to the caller of the method to handle the exception.

Code Example:

import [Link].*;

class Test {
// Declaring that this method might throw an IOException
void findFile() throws IOException {
throw new IOException("File not found");
}

public static void main(String[] args) {

Test obj = new Test();
try {
[Link]();
} catch (IOException e) {
[Link]("Caught: " + [Link]());
}
}
}

When to Use Exception Handling (Application)

1. Graceful Termination: To prevent the program from crashing when a user enters
invalid data or a network connection fails.
2. Resource Management: Using finally to ensure that system resources (like
memory or file handles) are released even if an error occurs.
3. Separation of Error Logic: It allows you to keep your main logic clean and separate
from error-handling code.
4. Debugging: It provides helpful error messages (stack traces) that help developers find
exactly where and why a program failed.

What are Built-in Exceptions in Java?

1. Built-in exceptions are those provided by the Java libraries (primarily in the
[Link] and [Link] packages) to handle common error conditions that occur
during program execution.
2. These are automatically available for use in any Java application.

Categories of Built-in Exceptions

1. Unchecked Exceptions (Runtime Exceptions)

These occur during the execution of the program and are subclasses of the
RuntimeException class. The compiler does not force you to handle these.
  ArithmeticException: Occurs during an illegal mathematical operation, such as
dividing by zero. (Mentioned in our previous discussion).
 NullPointerException: Occurs when you try to use a reference variable that points
to null.
 ArrayIndexOutOfBoundsException: Occurs when you try to access an array with an
index that is negative or greater than the array's size. (Mentioned in our discussion on
arrays).
 NumberFormatException: Occurs when a string cannot be converted into a numeric
format (e.g., trying to turn "ABC" into an integer).

2. Checked Exceptions

These are exceptions that the Java compiler forces you to handle using a try-catch block or
declare with the throws keyword. They are usually related to outside factors like files or
databases.

 IOException: Occurs during input or output failures, such as reading a file that
doesn't exist. (Mentioned in our previous discussion on throws).
 ClassNotFoundException: Occurs when the JVM tries to load a class but cannot
find its definition.
 SQLException: Occurs during database access errors.

Code Example of Built-in Exceptions

public class BuiltInDemo {
public static void main(String[] args) {
// Handling a built-in Unchecked Exception
try {
String text = null;
[Link]([Link]()); // Throws
NullPointerException
} catch (NullPointerException e) {
[Link]("Caught a NullPointerException!");
}

// Handling a built-in Checked Exception

try {
[Link]("NonExistentClass"); // Throws
ClassNotFoundException
} catch (ClassNotFoundException e) {
[Link]("Error: The class was not found.");
}
}
}
Advantages and Disadvantages

Advantages Disadvantages
Generic Nature: Sometimes a built-in
Standardization: Since these are built-in, every
exception is too broad and doesn't explain
Java developer understands what a
the specific context of your application's
NullPointerException means.
error.
Robustness: They provide a safety net for Overhead: Catching too many exceptions
common coding mistakes (like array index unnecessarily can make the code slower and
errors). harder to read.

Application

1. Built-in exceptions are used in defensive programming to ensure that an application

can handle invalid user inputs, missing files, or network issues without crashing.
2. They allow developers to create fault-tolerant software by providing specific
recovery paths for known error types.

Introduction to Multi-threading

1. Multi-threading in Java is a process of executing multiple threads simultaneously.

2. A thread is the smallest unit of processing. Multi-threading is a specialized form of
multi-tasking that allows a single program to perform multiple tasks at the same time,
which helps in maximum utilization of the CPU.

1. Creating a Thread by Extending the Thread Class

In this method, you create a new class that extends the built-in [Link] class.
This class must override the run() method, which contains the code that the thread will
execute.

 Execution: To start the thread, you create an object of your class and call the
start() method.

Code Example:

class MyThread extends Thread {

public void run() {
[Link]("Thread is running by extending Thread class.");
}
}

public class Main {

public static void main(String[] args) {
MyThread t1 = new MyThread();
[Link](); // This calls the run() method internally
}
}
2. Creating a Thread by Implementing the Runnable Interface

This is the more flexible way to create a thread. You create a class that implements the
[Link] interface and provide an implementation for the run() method.

 Execution: Since the class is not a Thread itself, you must wrap your Runnable
object inside a Thread object before calling start().

Code Example:

class MyRunnable implements Runnable {

public void run() {
[Link]("Thread is running by implementing Runnable
interface.");
}
}

public class Main {

public static void main(String[] args) {
MyRunnable myObj = new MyRunnable();
Thread t1 = new Thread(myObj); // Pass the runnable object to a
Thread constructor
[Link]();
}
}

Advantages and Disadvantages

Feature Advantages Disadvantages

Efficiency: It doesn't block the user Complexity: It is difficult to
Multi-
because threads are independent. You manage shared data (race
threading
can perform multiple operations at once. conditions) and debug errors.
Inheritance Limit: Since Java
doesn't support multiple
Extending Simplicity: It is easier to write and use
inheritance, once you extend
Thread simple thread methods directly.
Thread, you cannot extend any
other class.
Flexibility: Your class can still extend Verbosity: It requires an extra
Implementing
another class (like BaseController). It step of creating a Thread object
Runnable
is better for object-oriented design. and passing the runnable to it.

Application

 Web Servers: Handling multiple user requests at the same time.

 Gaming: One thread handles the graphics, another handles the music, and another
handles user input.
 Background Tasks: Downloading a file in the background while the user continues
to use an application.
 Parallel Processing: Breaking a large mathematical calculation into smaller parts to
run faster on multi-core processors.
The Life Cycle of a Thread in Java

1. A thread in Java always exists in one of several states.

2. These states are defined by the JVM and managed by the Thread Scheduler.

1. New State (Born State)

 This is the first state of a thread.

 A thread is in the New state when you create an instance of the Thread class (or a
subclass) but have not yet called the start() method.
 At this point, the thread is just an object in memory and has not yet begun its
execution.

 Example: Thread t = new Thread(myRunnable);

2. Runnable State

Once the start() method is called, the thread moves from the New state to the Runnable
state. In this state, the thread is considered "ready to run." It is placed in the runnable pool
and is waiting for the Thread Scheduler to allocate CPU time to it.

 Note: Being in the Runnable state does not mean the thread is currently executing; it
means it is eligible to execute.

3. Running State

A thread enters the Running state when the Thread Scheduler picks it from the runnable
pool. This is the state where the code inside the run() method is actually being executed by
the CPU.

 Transition: A thread can move back to the Runnable state if it is "yielded" or if its
time slice (quantum) expires, allowing other threads to run.

4. Blocked / Waiting State (Non-Runnable)

A thread enters this state when it is alive but currently not eligible to run. It remains in this
state until a specific event occurs that moves it back to the Runnable state.

 Causes:
o Waiting for an I/O operation to complete.
o Waiting to acquire a monitor lock (synchronized block).
o Calling sleep(), wait(), or join().
 Recovery: Once the sleep time expires or the resource becomes available, the thread
moves back to the Runnable state (not directly to Running).
5. Dead State (Terminated State)

A thread enters the Dead or Terminated state when its run() method has finished execution.
This can happen normally (the task is done) or abnormally (due to an unhandled exception).

 Rule: Once a thread is dead, it cannot be restarted. If you call start() on a dead
thread, it will throw an IllegalThreadStateException.

Summary of the Thread Life Cycle

State Description Trigger Event

New Object created, but not started. new Thread()
Runnable Ready to run, waiting for CPU. start() method called.
Chosen by Thread
Running Actively executing run() code.
Scheduler.
sleep(), wait(), or
Blocked Alive but waiting for a resource.
I/O.
Dead Execution complete. run() method ends.

Advantages and Disadvantages of Thread Management

 Advantages: Efficient thread state management ensures that the CPU is never idle if
there is work to be done, improving application responsiveness.
 Disadvantages: Context switching (the process of moving threads between Running,
Runnable, and Blocked states) consumes CPU cycles and can slow down performance
if there are too many threads.

Introduction to Thread Methods

1. Thread methods are built-in functions in Java used to manage and control the
execution, synchronization, and state transitions of threads.
2. They allow developers to pause, resume, or terminate thread activity based on
program requirements.

Key Thread Methods and Their Functionality

1. sleep(long millis)

This method causes the currently executing thread to pause its execution for a specified
number of milliseconds.

 State Transition: Moves the thread from Running to Blocked/Waiting.

 Key Detail: It does not release any "locks" the thread currently holds.
2. wait() and notify()

These methods are used for Inter-thread Communication.

 wait(): Causes the current thread to wait until another thread calls notify() or
notifyAll() on the same object. Unlike sleep(), wait() releases the lock it holds.
 notify(): Wakes up a single thread that is waiting on that object's monitor.

3. suspend() and resume() (Deprecated)

 suspend(): Used to permanently pause a thread until resume() is called.

 resume(): Used to restart a suspended thread.
 Status: Both are deprecated (no longer recommended) because suspend() is
inherently deadlock-prone. If a thread holds a lock and is suspended, no other thread
can access that lock until it is resumed.

4. stop() (Deprecated)

Used to force a thread to stop executing immediately.

 Status: This method is deprecated and considered highly unsafe. It causes the thread
to unlock all monitors it has locked, which can leave objects in an inconsistent or
"damaged" state.

Code Example
class SharedResource {
synchronized void waitAndPrint() {
try {
[Link]("Thread waiting...");
wait(); // Thread releases lock and waits
[Link]("Thread Resumed!");
} catch (InterruptedException e) { [Link](); }
}

synchronized void wakeUp() {

notify(); // Wakes up the waiting thread
}
}

public class ThreadMethodDemo {

public static void main(String[] args) throws InterruptedException {
SharedResource obj = new SharedResource();

Thread t1 = new Thread(() -> [Link]());

[Link]();

[Link](2000); // Main thread sleeps for 2 seconds

new Thread(() -> [Link]()).start();
}
}
Advantages and Disadvantages

Feature Advantages Disadvantages

Efficiency: Allows threads to
Complexity: Must be called from within a
wait for specific conditions
wait/notify synchronized block, or it throws an
without wasting CPU cycles
IllegalMonitorStateException.
(busy-waiting).
Simplicity: Easy to use for Lack of Control: You cannot "wake up" a
sleep creating delays or intervals sleeping thread prematurely except by
between tasks. interrupting it.
Safety Risks: These can cause deadlocks or
stop/suspend None (in modern Java). data corruption, which is why they are
deprecated.

Application

 wait and notify: Used in the Producer-Consumer pattern, where one thread
creates data and another thread processes it.
 sleep: Used in polling mechanisms (e.g., checking for updates every 10 seconds) or
for creating simple animations.
 Safe Termination: Instead of stop(), developers now use a boolean flag (like
volatile boolean running) to signal a thread to exit its run() method gracefully.
 UNIT-V

Introduction to Streams

In Java, a Stream is a sequence of data elements. There are two primary contexts for
"Streams" in Java:

1. I/O Streams ([Link]): Used for reading and writing data to various sources like
files, memory, or network connections.
2. Stream API ([Link]): Introduced in Java 8, this is a way to process
collections of objects in a functional and declarative style.

Concept of the Stream API

The Stream API is not a data structure (it doesn't store data); instead, it carries values from a
source (like an Array or a Collection) through a pipeline of computational steps.

The Pipeline Stages:

 Source: A collection, an array, or an I/O resource.

 Intermediate Operations: These transform a stream into another stream (e.g.,
filter, map, sorted). They are lazy, meaning they don't execute until a terminal
operation is called.
 Terminal Operation: This produces a result or a side-effect (e.g., forEach, collect,
reduce). Once this is called, the stream is consumed and cannot be used again.

Code Example (Stream API)

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

public class StreamDemo {

public static void main(String[] args) {
List<String> names = [Link]("Rahul", "Amit", "Suresh",
"Ankit");

// Concept: Filter names starting with 'A' and convert them to

Uppercase
List<String> result = [Link]()
.filter(name -> [Link]("A")) // Intermediate
.map(String::toUpperCase) // Intermediate
.collect([Link]()); // Terminal

[Link](result); // Output: [AMIT, ANKIT]

}
}
Advantages and Disadvantages

Advantages Disadvantages
Performance Overhead: For very small
Conciseness: Reduces boilerplate code (no need
datasets, traditional loops are often faster
for complex loops and conditional checks).
than streams.
Debugging: It is harder to set breakpoints
Readability: The code describes what to do
or step through code inside a stream
rather than how to do it (declarative).
pipeline.
Parallelism: You can easily process data in Learning Curve: Requires an
parallel using .parallelStream() to utilize understanding of lambda expressions and
multi-core CPUs. functional programming concepts.

Application

Streams are extensively used in data processing, filtering large datasets, aggregating
values (like finding a sum or average), and converting data from one format to another
(mapping).

Introduction to Stream Classes

1. In Java, Stream Classes are part of the [Link] package and are used to perform
input and output operations.
2. A "stream" is a continuous flow of data from a source (like a file or keyboard) to a
destination (like a console or file).
3. Java categorizes these classes based on the type of data they handle: bytes or
characters.

Types of Stream Classes

1. Byte Stream Classes

Byte streams are used to handle input and output of 8-bit bytes. They are primarily used for
reading or writing binary data like images, audio, or video files.

 InputStream (Superclass): Used to read data from a source.

o Subclasses: FileInputStream, BufferedInputStream, DataInputStream.
 OutputStream (Superclass): Used to write data to a destination.
o Subclasses: FileOutputStream, BufferedOutputStream, PrintStream.

2. Character Stream Classes

Character streams are used to handle 16-bit Unicode characters. They are specifically
designed for reading and writing text data and automatically handle character encoding.

 Reader (Superclass): Used to read character data.

o Subclasses: FileReader, BufferedReader, InputStreamReader.
 Writer (Superclass): Used to write character data.
 o Subclasses: FileWriter, BufferedWriter, PrintWriter.

Code Example (Character Stream)

import [Link].*;

public class StreamClassDemo {

public static void main(String[] args) {
// Using FileWriter and FileReader (Character Streams)
try {
// Writing to a file
FileWriter writer = new FileWriter("[Link]");
[Link]("Hello, Java Stream Classes!");
[Link]();

// Reading from the file

FileReader reader = new FileReader("[Link]");
int i;
while ((i = [Link]()) != -1) {
[Link]((char) i);
}
[Link]();
} catch (IOException e) {
[Link]("An error occurred: " + [Link]());
}
}
}

Advantages and Disadvantages

Feature Advantages Disadvantages

Versatility: Can handle any type of Encoding: Does not handle character
Byte
data, including non-text files (images, sets (like UTF-8) automatically, which
Streams
PDF). can lead to text errors.
Internationalization: Automatically Limited: Cannot be used effectively
Character
handles Unicode characters, making it for binary data like images or
Streams
ideal for text in different languages. compiled code.
Complexity: Requires wrapping basic
Performance: Reduces the number of
Buffered streams (e.g., new
I/O operations by reading/writing data
Streams BufferedReader(new
in chunks (buffers).
FileReader(file))).

Application and Functionality

 File Handling: Reading configuration files or writing logs to a disk.

 Network Communication: Sending and receiving data packets over a socket
connection.
 Standard I/O: [Link] is an InputStream and [Link] is a PrintStream,
used for basic console interaction.
 Data Serialization: Converting objects into a byte stream to be stored or transmitted
and then reconstructed later.
Introduction to Stream Classes

1. In Java, Stream Classes are part of the [Link] package and are used to perform
input and output operations.
2. A "stream" is a continuous flow of data from a source (like a file or keyboard) to a
destination (like a console or file).
3. Java categorizes these classes based on the type of data they handle: bytes or
characters.

Types of Stream Classes

1. Byte Stream Classes

Byte streams are used to handle input and output of 8-bit bytes. They are primarily used for
reading or writing binary data like images, audio, or video files.

 InputStream (Superclass): Used to read data from a source.

o Subclasses: FileInputStream, BufferedInputStream, DataInputStream.
 OutputStream (Superclass): Used to write data to a destination.
o Subclasses: FileOutputStream, BufferedOutputStream, PrintStream.

2. Character Stream Classes

Character streams are used to handle 16-bit Unicode characters. They are specifically
designed for reading and writing text data and automatically handle character encoding.

 Reader (Superclass): Used to read character data.

o Subclasses: FileReader, BufferedReader, InputStreamReader.
 Writer (Superclass): Used to write character data.
o Subclasses: FileWriter, BufferedWriter, PrintWriter.

Code Example (Character Stream)

import [Link].*;

public class StreamClassDemo {

public static void main(String[] args) {
// Using FileWriter and FileReader (Character Streams)
try {
// Writing to a file
FileWriter writer = new FileWriter("[Link]");
[Link]("Hello, Java Stream Classes!");
[Link]();

// Reading from the file

FileReader reader = new FileReader("[Link]");
int i;
while ((i = [Link]()) != -1) {
[Link]((char) i);
}
[Link]();
} catch (IOException e) {
[Link]("An error occurred: " + [Link]());
 }
}
}

Advantages and Disadvantages

Feature Advantages Disadvantages

Versatility: Can handle any type of Encoding: Does not handle character
Byte
data, including non-text files (images, sets (like UTF-8) automatically, which
Streams
PDF). can lead to text errors.
Internationalization: Automatically Limited: Cannot be used effectively
Character
handles Unicode characters, making it for binary data like images or
Streams
ideal for text in different languages. compiled code.
Complexity: Requires wrapping basic
Performance: Reduces the number of
Buffered streams (e.g., new
I/O operations by reading/writing data
Streams BufferedReader(new
in chunks (buffers).
FileReader(file))).

Application and Functionality

 File Handling: Reading configuration files or writing logs to a disk.

 Network Communication: Sending and receiving data packets over a socket
connection.
 Standard I/O: [Link] is an InputStream and [Link] is a PrintStream,
used for basic console interaction.
 Data Serialization: Converting objects into a byte stream to be stored or transmitted
and then reconstructed later.

Introduction to Byte Stream Classes

1. In Java, Byte Stream classes are part of the [Link] package and are used to perform
input and output of 8-bit bytes.
2. They are the most basic form of I/O in Java and are used for reading or writing
binary data, such as images, audio files, video files, or any compiled code.

Hierarchy of Byte Stream Classes

Byte streams are defined by two class hierarchies rooted in abstract classes:

1. InputStream (For Reading)

This abstract superclass defines the methods for receiving bytes from a source.

 FileInputStream: Used to read data from a file.

 BufferedInputStream: Wraps another input stream to provide buffering, which
improves performance by reducing the number of calls to the native API.
 DataInputStream: Allows an application to read primitive Java data types from an
underlying input stream in a machine-independent way.
2. OutputStream (For Writing)

This abstract superclass defines the methods for sending bytes to a destination.

 FileOutputStream: Used to write data to a file.

 BufferedOutputStream: Provides a buffer for output operations to increase
efficiency.
 PrintStream: Contains methods like print() and println() to write various data
types as text (Note: [Link] is a PrintStream).

Code Example: Copying an Image File

import [Link].*;

public class ByteStreamExample {

public static void main(String[] args) {
// Using Byte Streams to copy a binary file
try (FileInputStream in = new FileInputStream("[Link]");
FileOutputStream out = new
FileOutputStream("output_copy.jpg")) {

int byteData;
// Read one byte at a time until the end of the file (-1)
while ((byteData = [Link]()) != -1) {
[Link](byteData);
}
[Link]("File copied successfully!");
} catch (IOException e) {
[Link]("An error occurred: " + [Link]());
}
}
}

Advantages and Disadvantages

Feature Advantages Disadvantages

Can handle any type of file, Not ideal for text: Does not handle character
Versatility including images, PDFs, and encoding (Unicode) automatically, which can lead
executable files. to "garbage" text if not handled carefully.
Operates at the most
Performance: Reading one byte at a time
Simplicity fundamental level of data
(without buffering) is very slow for large files.
(bytes).

Application

 Multimedia Processing: Essential for reading and writing image, audio, and video
files.
 Network Communication: Used for sending raw data packets over sockets.
 File Copying: The most reliable way to copy files where the content format is
unknown.
Introduction to the File Class and I/O Exception

1. In Java, the File class (from [Link]) is an abstract representation of file and
directory pathnames.
2. It is used to create, delete, and inspect properties of files (like size or permissions).
3. Because interacting with a physical disk can fail (e.g., the disk is full or the file is
missing), most operations involving the File class require handling the IOException.

Creation of Files and Handling Primitive Data Types

1. Creation of Files: To create a physical file on the disk, you first initialize a File
object with a path and then call the createNewFile() method.
2. Reading and Writing Bytes: As discussed in our section on Byte Streams,
FileInputStream and FileOutputStream are used to read and write raw 8-bit data.
3. Handling Primitive Data Types: To read or write Java primitives (like int, double,
or boolean) directly, you use DataOutputStream and DataInputStream. These
"wrap" around a byte stream to provide methods like writeInt() or readDouble().

Code Example
import [Link].*;

public class FileIODemo {

public static void main(String[] args) {
File myFile = new File("[Link]");

try {
// 1. Creation of file
if ([Link]()) {
[Link]("File created: " + [Link]());
}

// 2. Writing Bytes and Primitive Data

FileOutputStream fos = new FileOutputStream(myFile);
DataOutputStream dos = new DataOutputStream(fos);

[Link](123); // Primitive int

[Link](45.67); // Primitive double
[Link]("Java I/O"); // String
[Link]();

// 3. Reading Bytes and Primitive Data

FileInputStream fis = new FileInputStream(myFile);
DataInputStream dis = new DataInputStream(fis);

[Link]("Int: " + [Link]());

[Link]("Double: " + [Link]());
[Link]("String: " + [Link]());
[Link]();

} catch (IOException e) { // Handling I/O Exception

[Link]("An error occurred during I/O operations.");
[Link]();
}
}}
Advantages and Disadvantages

Feature Advantages Disadvantages

Allows for platform-independent
It cannot read or write the content of a
File Class file management (works on
file; it only manages the file as an object.
Windows, Linux, Mac).
Allows you to store and retrieve Data stored this way is binary; you
DataStream primitive data in a machine- cannot open the file in a text editor and
independent format. read the numbers easily.
IOException
Provides a standard way to handle Can make code "noisy" with many try-
hardware or system-level failures. catch blocks or throws declarations.

Application

 Persistent Storage: Saving user settings, high scores in games, or application state.
 Data Serialization: Writing complex data structures to a file to be sent over a
network.
 Logging: Creating and managing log files to track application errors or performance.

……………………………………………………………………………………………………………………