haque arabic & p

rul er
sia
ha
az n
m u

ni
a

ve
an

rsi
Maul

Patna Bihar

ty
BCA Part – III
2022-2025

Name: Saptarshi Roy

Roll NO: 232750200016
Reg. no.: 16202204241

Java
 Acknowledgement:

I sincerely thank my respected teacher for their guidance and support during the preparation of this Java

assignment.

I am also grateful to Maulana Mazharul Haque Arabic & Persian University for providing the resources and

opportunity to complete this project.

Lastly, I appreciate my friends and family for their constant motivation throughout this journey.

Saptarshi Roy

BCA (Final Year)

Introduction:
 Java is one of the most widely used and versatile programming languages in the world. It is an object-

oriented, platform-independent, and robust language that enables developers to create secure, reliable, and

efficient applications. Due to its “write once, run anywhere” capability, Java is extensively used in desktop

applications, web applications, mobile development, and enterprise solutions.

This assignment is aimed at applying the core concepts of Java, such as classes and objects,

inheritance, polymorphism, exception handling, interfaces, and file handling, to solve practical problems. By

working on this project, I was able to enhance my understanding of Java programming, improve my coding

skills, and gain hands-on experience in developing efficient solutions using Java.

Through this assignment, I also learned the importance of logical thinking, debugging, and proper

documentation while writing programs, which will help me in my future academic and professional journey.

Table of Contents:
• Chapter 1: Introduction to Java and Programming Concepts

• Chapter 2: Setting Up Your Java Development Environment

• Chapter 3: Variables, Data Types, and Operators in Java

• Chapter 4: Control Flow Statements: Decision Making

• Chapter 5: Control Flow Statements: Loops and Iteration

• Chapter 6: Introduction to Objects and Classes

• Chapter 7: Methods and Constructors in Java

• Chapter 8: Arrays and Strings

• Chapter 9: Inheritance and Polymorphism

• Chapter 10: Exception Handling in Java

• Chapter 11: Input and Output Streams

• Chapter 12: Introduction to GUI Programming with Swing

• Chapter 13: Working with Collections

• Chapter 14: Multithreading Basics

• Chapter 15: Introduction to Java Database Connectivity (JDBC)

Chapter 1: Introduction to Java and Programming Concepts

1.1 What is Programming?

Programming is providing instructions to a computer to perform a task. It's like writing a recipe. The computer
follows your instructions (the program) step-by-step. Computers are powerful but need clear, specific
instructions.

1.2 Why Learn Programming?

1. Problem-Solving: Breaks down complex problems.

2. Creativity: Allows you to build solutions.
3. Career: High demand for programmers.
4. Understanding Tech: Helps navigate the digital world.
5. Automation: Automates repetitive tasks.

1.3 What is Java?

Java is a popular, object-oriented programming language. Created by James Gosling at Sun Microsystems (now
Oracle). Known for:

1. Platform Independence: "Write Once, Run Anywhere" (WORA). Works on any system with the Java
Virtual Machine (JVM).
2. Object-Oriented: Uses objects and classes.
3. Simple: Relatively easy to learn.
4. Robust and Secure: Handles errors and security threats.
5. Versatile: Used for web, mobile (Android), enterprise apps.

1.4 The Java Virtual Machine (JVM)

The JVM is like a translator. Java code is compiled into bytecode, which the JVM then converts into
instructions the computer can understand. This makes Java platform-independent.

1.5 Java Development Kit (JDK)

The JDK is the set of tools you need to develop Java programs. It includes the compiler, JVM, and other
utilities.

1.6 A Simple Java Program

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
public class HelloWorld {
public static void main(String[] args) {
[Link]("Hello, World!");
}
}

Explanation:

1. public class HelloWorld: Defines a class named HelloWorld. All Java code lives inside classes.
2. public static void main(String[] args): The main method is the starting point of the program.
3. [Link]("Hello, World!");: Prints the text to the console.

1.7 Compiling and Running Java

1. Write the code: Save the code in a file named [Link].

2. Compile: Open a command prompt/terminal and type: javac [Link]
3. Run: Type: java HelloWorld

1.8 Basic Concepts Recap

1. Variables: Store data (e.g., int age = 20;).

2. Data Types: Define the type of data (e.g., int, String).
3. Operators: Perform operations (+, -, *, /, ==, !=, &&, ||).
4. Control Flow: if, else, for, while control the order of execution.

Chapter 2: Setting Up Your Java Development Environment

2.1 Installing the JDK

1. Download: Go to Oracle's website or Adoptium (Eclipse Temurin) and download the JDK for your
operating system.
2. Install: Run the installer and follow the instructions.
3. Environment Variables: Crucially important!
1. JAVA_HOME: Points to the JDK installation directory.
2. PATH: Includes $JAVA_HOME/bin (Linux/macOS) or %JAVA_HOME%\bin (Windows) so you can
run java and javac from anywhere.

Windows Example:

1. Right-click "This PC" -> Properties -> Advanced system settings -> Environment Variables.
2. Create a new System variable JAVA_HOME with the JDK path (e.g., C:\Program Files\Java\jdk-17).
3. Edit the Path variable and add %JAVA_HOME%\bin.

macOS/Linux Example:

1. Edit .bashrc or .zshrc in your home directory.

2. Add:

bash<button><svg><path></path></svg><span>Copy code</span><span></span></button>
export JAVA_HOME=/path/to/jdk
export PATH=$JAVA_HOME/bin:$PATH

(Replace /path/to/jdk with the actual JDK path.)

3. Run source ~/.bashrc or source ~/.zshrc.

• Verify: Open a new command prompt/terminal and type java -version and javac -version. You should
see version information.

2.2 Integrated Development Environments (IDEs)

IDEs make coding easier! Popular options:

• Eclipse: Free, open-source.

• IntelliJ IDEA: Commercial (free Community Edition available). Powerful.
• NetBeans: Free, open-source.

2.3 Installing and Using Eclipse (Example)

1. Download: Download "Eclipse IDE for Java Developers" from the Eclipse website.
2. Extract: Unzip the downloaded file.
3. Run: Run [Link] (Windows) or the eclipse executable (macOS/Linux).
4. Create a Project: File -> New -> Java Project.
5. Create a Class: Right-click src -> New -> Class.
6. Write Code: Type your Java code in the class editor.
7. Run: Right-click in the editor -> Run As -> Java Application.

Chapter 3: Variables, Data Types, and Operators in Java

3.1 Variables

A variable is a named storage location. You must declare the type of data it will hold.

Declaration:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
dataType variableName;

Example:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
int age; // Declares an integer variable named 'age'
String name; // Declares a String variable named 'name'

Initialization:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
age = 25; // Assigns the value 25 to the 'age' variable
name = "Alice"; // Assigns the string "Alice" to the 'name' variable

You can combine declaration and initialization:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
int age = 25;
String name = "Alice";

3.2 Data Types

1. Primitive Types: Built-in data types.

1. int: Integer numbers (e.g., -10, 0, 25).
2. float: Floating-point numbers (single-precision) (e.g., 3.14f). Note the 'f' suffix!
3. double: Floating-point numbers (double-precision) (e.g., 3.14159). Preferred for most floating-
point calculations.
4. boolean: true or false.
5. char: A single character (e.g., 'A', 'z', '5').
6. byte: Small integer (-128 to 127).
7. short: Short integer.
8. long: Large integer (e.g., 1234567890123L). Note the 'L' suffix!
2. Non-Primitive Types (Reference Types): Created by programmers.
1. String: A sequence of characters (e.g., "Hello"). Important! Treated specially in Java.

3.3 Operators
Symbols that perform operations.

1. Arithmetic Operators: + (addition), - (subtraction), * (multiplication), / (division), % (modulo -

remainder).
2. Assignment Operator: = (assigns a value to a variable).
3. Comparison Operators: == (equal to), != (not equal to), > (greater than), < (less than), >= (greater than
or equal to), <= (less than or equal to). Return a boolean value.
4. Logical Operators: && (AND), || (OR), ! (NOT). Used with boolean expressions.
5. Increment/Decrement Operators: ++ (increment), -- (decrement). i++ is equivalent to i = i + 1;.

3.4 Operator Precedence

Operators have an order of precedence (like in math). Use parentheses () to force a specific order. Example:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
int result = 5 + 3 * 2; // result will be 11 (multiplication before addition)
int result2 = (5 + 3) * 2; // result2 will be 16 (parentheses first)

Chapter 4: Control Flow Statements: Decision Making

4.1 if Statement

Executes a block of code only if a condition is true.

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
if (condition) {
// Code to execute if the condition is true
}

Example:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
int age = 18;
if (age >= 18) {
[Link]("You are eligible to vote.");
}

4.2 else Statement

Executes a block of code if the if condition is false.

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
if (condition) {
// Code to execute if the condition is true
} else {
// Code to execute if the condition is false
}

Example:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
int age = 15;
if (age >= 18) {
[Link]("You are eligible to vote.");
} else {
[Link]("You are not eligible to vote yet.");
}

4.3 else if Statement

Chains multiple conditions together.

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
if (condition1) {
// Code to execute if condition1 is true
} else if (condition2) {
// Code to execute if condition2 is true
} else {
// Code to execute if none of the conditions are true
}
Example:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
int score = 75;
if (score >= 90) {
[Link]("Grade: A");
} else if (score >= 80) {
[Link]("Grade: B");
} else if (score >= 70) {
[Link]("Grade: C");
} else {
[Link]("Grade: D");
}

4.4 Nested if Statements

if statements inside other if statements.

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
if (condition1) {
if (condition2) {
// Code to execute if both condition1 and condition2 are true
}
}

4.5 switch Statement

A multi-way branch that compares a variable to different values.

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
switch (variable) {
case value1:
// Code to execute if variable == value1
break; // Important! Prevents "fall-through"
case value2:
// Code to execute if variable == value2
break;
default:
// Code to execute if variable doesn't match any case
}

Example:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
int day = 3;
String dayName;
switch (day) {
case 1:
dayName = "Monday";
break;
case 2:
dayName = "Tuesday";
break;
case 3:
dayName = "Wednesday";
break;
 default:
dayName = "Invalid day";
}
[Link](dayName); // Output: Wednesday

Chapter 5: Control Flow Statements: Loops and Iteration

5.1 for Loop

Used when you know how many times you want to repeat a block of code.

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
for (initialization; condition; increment/decrement) {
// Code to execute repeatedly
}

Example:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
for (int i = 0; i < 5; i++) {
[Link]("Iteration: " + i);
}

Explanation:

1. initialization: int i = 0; Creates a counter variable i and sets it to 0. Executed only once at the beginning.
2. condition: i < 5; The loop continues as long as i is less than 5.
3. increment/decrement: i++; Increases the value of i by 1 after each iteration.

5.2 while Loop

Used when you want to repeat a block of code as long as a condition is true.

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
while (condition) {
// Code to execute repeatedly
}

Example:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
int count = 0;
while (count < 5) {
[Link]("Count: " + count);
count++; // Important! Otherwise, the loop will run forever!
}

5.3 do-while Loop

Similar to while, but the code block is executed at least once before the condition is checked.

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
do {
// Code to execute repeatedly
} while (condition);

Example:
java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
int number = 10;
do {
[Link]("Number: " + number);
number--;
} while (number > 0);

5.4 break Statement

Immediately exits a loop.

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
for (int i = 0; i < 10; i++) {
if (i == 5) {
break; // Exit the loop when i is 5
}
[Link](i);
}

5.5 continue Statement

Skips the current iteration of a loop and proceeds to the next iteration.

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
for (int i = 0; i < 10; i++) {
if (i % 2 == 0) {
continue; // Skip even numbers
}
[Link](i); // Prints only odd numbers
}

5.6 Nested Loops

Loops inside other loops.

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
[Link]("i: " + i + ", j: " + j);
}
}

Chapter 6: Introduction to Objects and Classes

6.1 Objects and Classes: The Basics

1. Class: A blueprint or template for creating objects. It defines the attributes (data) and behaviors
(methods) that objects of that class will have.
2. Object: An instance of a class. It's a real-world entity that has state (data) and behavior (methods).

Analogy:

1. Class: Cookie cutter

2. Object: Cookie made with that cookie cutter

6.2 Creating a Class

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
public class Dog {
// Attributes (instance variables)
String breed;
String name;
int age;

// Methods (behaviors)
public void bark() {
[Link]("Woof!");
}

public void displayInfo() {

[Link]("Breed: " + breed + ", Name: " + name + ", Age: " + age);
}
}

Explanation:

1. public class Dog: Declares a class named Dog.

2. String breed;, String name;, int age;: Declare attributes (instance variables) that describe a Dog. Each
Dog object will have its own breed, name, and age.
3. public void bark(): Defines a method (behavior) that makes the dog bark.
4. public void displayInfo(): Defines a method to display the dog's information.

6.3 Creating Objects

Use the new keyword to create an object from a class.

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
Dog myDog = new Dog(); // Creates a new Dog object

6.4 Accessing Object Members

Use the dot operator (.) to access the attributes and methods of an object.

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
[Link] = "Golden Retriever";
[Link] = "Buddy";
[Link] = 3;

[Link](); // Calls the bark() method

[Link](); // Calls the displayInfo() method

Chapter 7: Methods and Constructors in Java

7.1 Methods: The Building Blocks of Behavior

Methods are blocks of code that perform specific tasks.

Defining a Method:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
public returnType methodName(parameterList) {
// Method body (code to execute)
return returnValue; // If the returnType is not void
}

Example:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
public class Calculator {
public int add(int a, int b) {
int sum = a + b;
return sum;
}
}

Explanation:

1. public: Access modifier (more on this later).

2. int: Return type (the method returns an integer value).
3. add: Method name.
4. (int a, int b): Parameter list (the method takes two integer parameters).
5. return sum;: Returns the calculated sum.

Calling a Method:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
Calculator calc = new Calculator();
int result = [Link](5, 3); // Calls the add() method with arguments 5 and 3
[Link](result); // Output: 8

7.2 Types of Methods

• Instance Methods: Operate on a specific object. They have access to the object's instance variables.
The bark() and displayInfo() methods in the Dog class are instance methods.
• Static Methods: Belong to the class itself, not to any specific object. You can call them directly using
the class name.

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
public class MathUtils {
public static int square(int x) {
return x * x;
}
}
int squaredValue = [Link](4); // Call the static method using the class name

7.3 Method Overloading

Defining multiple methods with the same name but different parameters.

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
public class Overloader {
public int add(int a, int b) {
return a + b;
}

public double add(double a, double b) {

return a + b;
}
}

The compiler knows which add method to call based on the arguments you pass.

7.4 Constructors

Special methods that are called when an object is created. They initialize the object's state.

Defining a Constructor:

• The constructor has the same name as the class.

• It doesn't have a return type (not even void).

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
public class Person {
String name;
int age;

public Person(String name, int age) {

[Link] = name;
[Link] = age;
}
}

Explanation:

1. public Person(String name, int age): A constructor that takes a name and an age as parameters.
2. [Link] = name;: Assigns the parameter name to the instance variable name. this refers to the
current object.

Creating an Object Using a Constructor:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
Person person1 = new Person("Bob", 30); // Creates a new Person object using the constructor

7.5 Default Constructor

If you don't define any constructors in a class, Java automatically provides a default constructor (a constructor
with no parameters). However, if you define any constructor, you must define the default constructor
explicitly if you want to use it.
 Chapter 8: Arrays and Strings

8.1 Arrays: Collections of Data

An array is a fixed-size, ordered collection of elements of the same data type.

Declaring an Array:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
dataType[] arrayName;

Creating an Array:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
arrayName = new dataType[arraySize];

Combining Declaration and Creation:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
int[] numbers = new int[5]; // Creates an integer array of size 5

Initializing Array Elements:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;
numbers[3] = 40;
numbers[4] = 50;

Array Literals (Shorthand):

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
int[] numbers = {10, 20, 30, 40, 50}; // Creates and initializes an array in one step

Accessing Array Elements:

Use the index (position) of the element. Array indices start at 0.

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
int firstNumber = numbers[0]; // firstNumber will be 10

Array Length:

Use the length property to get the number of elements in the array.

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
int arrayLength = [Link]; // arrayLength will be 5
Looping Through an Array:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
for (int i = 0; i < [Link]; i++) {
[Link]("Element at index " + i + ": " + numbers[i]);
}

8.2 Multi-Dimensional Arrays

Arrays of arrays.

Declaring and Creating a 2D Array:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
int[][] matrix = new int[3][3]; // Creates a 3x3 matrix

Initializing 2D Array Elements:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
matrix[0][0] = 1;
matrix[0][1] = 2;
matrix[0][2] = 3;
matrix[1][0] = 4;
matrix[1][1] = 5;
matrix[1][2] = 6;
matrix[2][0] = 7;
matrix[2][1] = 8;
matrix[2][2] = 9;

Looping Through a 2D Array:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
for (int i = 0; i < [Link]; i++) {
for (int j = 0; j < matrix[i].length; j++) {
[Link](matrix[i][j] + " ");
}
[Link]();
}

8.3 Strings: Working with Text

String is a class in Java used to represent sequences of characters. Important: Strings are immutable in Java.
This means that once a String object is created, its value cannot be changed.

Creating Strings:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
String message = "Hello, World!";
String emptyString = "";
String Methods:

1. length(): Returns the number of characters in the string.

2. charAt(int index): Returns the character at the specified index.
3. substring(int beginIndex, int endIndex): Returns a substring starting at beginIndex (inclusive) and
ending at endIndex (exclusive).
4. equals(String anotherString): Compares two strings for equality (case-sensitive). Use this instead of ==
for comparing String content.
5. equalsIgnoreCase(String anotherString): Compares two strings for equality (case-insensitive).
6. toUpperCase(): Converts the string to uppercase.
7. toLowerCase(): Converts the string to lowercase.
8. indexOf(String str): Returns the index of the first occurrence of the specified substring.
9. lastIndexOf(String str): Returns the index of the last occurrence of the specified substring.
10. replace(String oldChar, String newChar): Replaces all occurrences of oldChar with newChar.
11. trim(): Removes leading and trailing whitespace.
12. split(String regex): Splits the string into an array of substrings based on the specified delimiter.
13. concat(String str): Concatenates (joins) two strings. (Easier to just use the + operator).

String Concatenation:

Use the + operator to concatenate strings.

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
String firstName = "John";
String lastName = "Doe";
String fullName = firstName + " " + lastName; // fullName will be "John Doe"

String Immutability:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
String text = "Hello";
text = text + ", World!"; // A new String object is created, text now references it. The original "Hello" String is unchanged.
 Chapter 9: Inheritance and Polymorphism

9.1 Inheritance: Code Reusability

Inheritance allows you to create new classes (subclasses or derived classes) based on existing classes
(superclasses or base classes). The subclass inherits the attributes and methods of the superclass.

Keywords:

1. extends: Used to indicate inheritance.

Syntax:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
class Subclass extends Superclass {
// Subclass attributes and methods
}

Example:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
class Animal {
String name;

public void eat() {

[Link]("Animal is eating");
}
}

class Dog extends Animal {

String breed;

public void bark() {

[Link]("Woof!");
}
}

Explanation:

1. Animal is the superclass.

2. Dog is the subclass. Dog inherits the name attribute and the eat() method from Animal.
3. Dog also has its own attributes and methods (e.g., breed, bark()).

9.2 Types of Inheritance (Java supports single inheritance for classes):

1. Single Inheritance: A class can inherit from only one superclass. (Java enforces this for classes directly).
9.3 Method Overriding

A subclass can provide its own implementation of a method that is already defined in the superclass. This is
called method overriding.

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
class Animal {
public void makeSound() {
[Link]("Generic animal sound");
}
}

class Dog extends Animal {

@Override // Good practice to use @Override annotation
public void makeSound() {
[Link]("Woof!"); // Overrides the makeSound() method
}
}

9.4 super Keyword

Used to access members of the superclass from within the subclass.

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
class Animal {
String name;

public Animal(String name) {

[Link] = name;
}

public void eat() {

[Link]("Animal is eating");
}
}

class Dog extends Animal {

String breed;

public Dog(String name, String breed) {

super(name); // Calls the Animal constructor to initialize the name
[Link] = breed;
}

@Override
public void eat() {
[Link](); // Calls the Animal's eat() method
[Link]("Dog is eating a bone");
}
}
9.5 Polymorphism: Many Forms

Polymorphism allows objects of different classes to be treated as objects of a common type.

1. Method Overriding (Runtime Polymorphism): The correct method to call is determined at runtime
based on the actual type of the object.

Example:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
Animal animal1 = new Animal("Generic Animal");
Animal animal2 = new Dog("Buddy", "Golden Retriever");

[Link](); // Output: Generic animal sound

[Link](); // Output: Woof! (The Dog's makeSound() method is called)
 Chapter 10: Exception Handling in Java

10.1 What are Exceptions?

Exceptions are events that disrupt the normal flow of program execution. They represent errors or unusual
conditions.

10.2 try-catch Blocks

Used to handle exceptions.

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
try {
// Code that might throw an exception
} catch (ExceptionType e) {
// Code to execute if an exception of type ExceptionType is thrown
}

Example:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
try {
int result = 10 / 0; // This will throw an ArithmeticException
[Link]("Result: " + result); // This line will not be executed
} catch (ArithmeticException e) {
[Link]("Error: Cannot divide by zero");
}

10.3 finally Block

The finally block is always executed, regardless of whether an exception is thrown or caught. It's typically used
to release resources (e.g., close files, database connections).

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
try {
// Code that might throw an exception
} catch (ExceptionType e) {
// Code to execute if an exception occurs
} finally {
// Code that will always be executed
}

10.4 Common Exception Classes

1. ArithmeticException: Division by zero.

2. NullPointerException: Trying to access a member of a null object.
3. ArrayIndexOutOfBoundsException: Trying to access an array element with an invalid index.
4. IOException: Input/output error (e.g., file not found).
5. FileNotFoundException: A specific type of IOException
6. ClassNotFoundException: Class not found when loading a class.
10.5 throw Keyword

Used to explicitly throw an exception.

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
public void checkAge(int age) {
if (age < 0) {
throw new IllegalArgumentException("Age cannot be negative");
}
[Link]("Age is valid");
}

10.6 throws Clause

Used in a method declaration to indicate that the method might throw a particular exception.

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
public void readFile(String filename) throws IOException {
// Code that reads a file (might throw an IOException)
}
 Chapter 11: Input and Output Streams

11.1 Streams: Reading and Writing Data

Streams are sequences of data that flow from a source to a destination.

1. InputStream: Used for reading data.

2. OutputStream: Used for writing data.

11.2 Reading from the Console (Scanner Class)

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
import [Link];

public class ConsoleInput {

public static void main(String[] args) {
Scanner scanner = new Scanner([Link]);

[Link]("Enter your name: ");

String name = [Link](); // Reads a line of text

[Link]("Enter your age: ");

int age = [Link](); // Reads an integer
[Link](); // Consume the newline character left by nextInt()

[Link]("Hello, " + name + "! You are " + age + " years old.");

[Link](); // Close the scanner to release resources

}
}

11.3 Reading from and Writing to Files

1. FileInputStream: Reads data from a file as bytes.

2. FileOutputStream: Writes data to a file as bytes.
3. FileReader: Reads data from a file as characters.
4. FileWriter: Writes data to a file as characters.
5. BufferedReader: Efficiently reads text from a character-input stream, buffering characters so as to
provide for the efficient reading of characters, arrays, and lines.
6. BufferedWriter: Writes text to a character-output stream, buffering characters so as to provide for the
efficient writing of single characters, arrays, and lines.

Example: Writing to a File

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
import [Link];
import [Link];

public class FileWrite {

public static void main(String[] args) {
try (FileWriter writer = new FileWriter("[Link]")) {
 [Link]("Hello, File!\n");
[Link]("This is a new line.\n");
} catch (IOException e) {
[Link]("An error occurred while writing to the file: " + [Link]());
}
}
}

Example: Reading from a File

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
import [Link];
import [Link];
import [Link];

public class FileReaderExample {

public static void main(String[] args) {
try (BufferedReader reader = new BufferedReader(new FileReader("[Link]"))) {
String line;
while ((line = [Link]()) != null) {
[Link](line);
}
} catch (IOException e) {
[Link]("An error occurred while reading from the file: " + [Link]());
}
}
}
 Chapter 12: Introduction to GUI Programming with Swing

12.1 What is Swing?

Swing is a GUI (Graphical User Interface) toolkit for Java. It allows you to create window-based applications
with buttons, labels, text fields, and other interactive components.

12.2 Creating a Simple Swing Application

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
import [Link].*;
import [Link].*;

public class SimpleGUI extends JFrame {

public SimpleGUI() {
setTitle("Simple GUI Example");
setSize(300, 200);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLayout(new FlowLayout()); // Use a layout manager

JLabel label = new JLabel("Hello, Swing!");

JButton button = new JButton("Click Me");

add(label);
add(button);

setVisible(true);
}

public static void main(String[] args) {

[Link](() -> new SimpleGUI());
}
}

Explanation:

1. import [Link].*: Imports the Swing classes.

2. extends JFrame: The SimpleGUI class inherits from JFrame, which is the main window.
3. setTitle(): Sets the title of the window.
4. setSize(): Sets the size of the window (width, height).
5. setDefaultCloseOperation(): Specifies what happens when the user closes the window.
6. setLayout(): Sets the layout manager, which controls how components are arranged. FlowLayout
arranges components in a row.
7. JLabel: Displays text.
8. JButton: A button that the user can click.
9. add(): Adds the components to the window.
10. setVisible(true): Makes the window visible.
11. [Link](): Ensures that the GUI is created and updated on the Event Dispatch Thread
(EDT), which is important for avoiding concurrency issues.
12.3 Common Swing Components

• JFrame: The main window.

• JLabel: Displays text.
• JButton: A clickable button.
• JTextField: A text field for user input.
• JTextArea: A multi-line text area for user input/output.
• JPanel: A container for grouping other components.

12.4 Layout Managers

Layout managers control how components are arranged in a container.

• FlowLayout: Arranges components in a row.

• BorderLayout: Arranges components in five regions: North, South, East, West, Center.
• GridLayout: Arranges components in a grid (rows and columns).
• BoxLayout: Arranges components in a single row or column.

12.5 Event Handling

Event handling allows you to respond to user interactions, such as button clicks.

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
import [Link].*;
import [Link].*;
import [Link];
import [Link];

public class ButtonClickExample extends JFrame {

public ButtonClickExample() {
setTitle("Button Click Example");
setSize(300, 200);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLayout(new FlowLayout());

JButton button = new JButton("Click Me");

JLabel label = new JLabel("Button not clicked");

[Link](new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
[Link]("Button clicked!");
}
});

add(button);
add(label);

setVisible(true);
}
 public static void main(String[] args) {
[Link](() -> new ButtonClickExample());
}
}
 Chapter 13: Working with Collections

13.1 The Java Collections Framework

The Java Collections Framework provides a set of interfaces and classes for storing and manipulating
collections of objects.

13.2 Common Collection Interfaces

12. List: An ordered collection that allows duplicate elements (e.g., ArrayList, LinkedList).
13. Set: An unordered collection that does not allow duplicate elements (e.g., HashSet, TreeSet).
14. Map: A collection that stores key-value pairs (e.g., HashMap, TreeMap).

13.3 ArrayList

A resizable array implementation of the List interface.

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
import [Link];
import [Link];

public class ArrayListExample {

public static void main(String[] args) {
List<String> names = new ArrayList<>();

[Link]("Alice");
[Link]("Bob");
[Link]("Charlie");
[Link]("Alice"); // Duplicates are allowed

[Link](names); // Output: [Alice, Bob, Charlie, Alice]

[Link]("Size: " + [Link]()); // Output: Size: 4

[Link]("Bob");
[Link](names); // Output: [Alice, Charlie, Alice]

[Link]("Element at index 0: " + [Link](0)); // Output: Element at index 0: Alice

}
}

13.4 LinkedList

A linked list implementation of the List interface. Efficient for inserting and deleting elements in the middle of
the list.

13.5 HashSet

A set implementation that does not allow duplicate elements.

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
import [Link];
import [Link];

public class HashSetExample {

public static void main(String[] args) {
Set<String> uniqueNames = new HashSet<>();

[Link]("Alice");
[Link]("Bob");
[Link]("Charlie");
[Link]("Alice"); // Duplicate is ignored

[Link](uniqueNames); // Output: [Bob, Alice, Charlie] (Order is not guaranteed)

[Link]("Size: " + [Link]()); // Output: Size: 3

}
}

13.6 HashMap

A map implementation that stores key-value pairs.

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
import [Link];
import [Link];

public class HashMapExample {

public static void main(String[] args) {
Map<String, Integer> ages = new HashMap<>();

[Link]("Alice", 25);
[Link]("Bob", 30);
[Link]("Charlie", 28);

[Link](ages); // Output: {Bob=30, Charlie=28, Alice=25}

[Link]("Age of Alice: " + [Link]("Alice")); // Output: Age of Alice: 25

[Link]("Bob");

[Link](ages); // Output: {Charlie=28, Alice=25}

}
}
 Chapter 14: Multithreading Basics

14.1 What is Multithreading?

Multithreading allows a program to execute multiple tasks concurrently. Each task is executed in a separate
thread.

14.2 Creating Threads

15. Using the Thread class:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
class MyThread extends Thread {
@Override
public void run() {
[Link]("Thread " + [Link]().getName() + " is running");
}

public static void main(String[] args) {

MyThread thread1 = new MyThread();
[Link](); // Starts the thread
}
}

16. Using the Runnable interface:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
class MyRunnable implements Runnable {
@Override
public void run() {
[Link]("Thread " + [Link]().getName() + " is running");
}

public static void main(String[] args) {

MyRunnable runnable = new MyRunnable();
Thread thread2 = new Thread(runnable);
[Link](); // Starts the thread
}
}

14.3 Thread Synchronization (Continued)

When multiple threads access the same shared resources, you need to synchronize them to prevent race
conditions. A race condition occurs when multiple threads try to access and modify shared data concurrently,
leading to unpredictable results.

17. synchronized Keyword:

 The synchronized keyword can be used to protect critical sections of code, ensuring that only one
thread can access the code at a time.

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
class Counter {
private int count = 0;

public synchronized void increment() {

count++;
}

public int getCount() {

return count;
}
}

Example:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
class Counter {
private int count = 0;

public synchronized void increment() {

count++;
}

public int getCount() {

return count;
}
}

public class ThreadSyncExample {

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

Runnable task = () -> {

for (int i = 0; i < 1000; i++) {
[Link]();
}
};

Thread thread1 = new Thread(task);

Thread thread2 = new Thread(task);

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

[Link](); // Wait for thread1 to finish

[Link](); // Wait for thread2 to finish

[Link]("Final count: " + [Link]()); // Should be 2000

}
}
Explanation:

18. The increment() method is declared as synchronized. This means that only one thread can execute this
method at a time.
19. [Link](); and [Link](); ensure that the main thread waits for thread1 and thread2 to
complete before printing the final count.

14.4 Thread States

20. New: The thread has been created but not yet started.
21. Runnable: The thread is ready to run.
22. Running: The thread is currently executing.
23. Blocked/Waiting: The thread is waiting for a resource or another thread.
24. Terminated: The thread has finished executing.
 Chapter 15: Introduction to Java Database Connectivity (JDBC)

15.1 What is JDBC?

JDBC (Java Database Connectivity) is a Java API for connecting to and interacting with databases. It allows you
to execute SQL queries, insert data, update data, and delete data from your Java programs.

15.2 JDBC Architecture

The JDBC architecture consists of the following components:

25. JDBC Driver: A software component that allows Java applications to connect to a specific database.
26. DriverManager: A class that manages JDBC drivers.
27. Connection: Represents a connection to a database.
28. Statement: Used to execute SQL queries.
29. ResultSet: Represents the result of a query.

15.3 Connecting to a Database

30. Load the JDBC Driver:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
try {
[Link]("[Link]"); // Example for MySQL
} catch (ClassNotFoundException e) {
[Link]("MySQL JDBC Driver not found: " + [Link]());
return;
}

31. Establish a Connection:

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
import [Link];
import [Link];
import [Link];

String url = "jdbc:mysql://localhost:3306/mydatabase"; // Database URL

String username = "myuser"; // Database username
String password = "mypassword"; // Database password

try (Connection connection = [Link](url, username, password)) {

[Link]("Connected to the database!");

} catch (SQLException e) {
[Link]("Connection failed: " + [Link]());
}

Important: Replace "[Link]", "jdbc:mysql://localhost:3306/mydatabase", "myuser",

and "mypassword" with the appropriate values for your database. Also ensure you have the correct
JDBC driver JAR file in your project's classpath.
15.4 Executing SQL Queries

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
import [Link];
import [Link];
import [Link];
import [Link];

String url = "jdbc:mysql://localhost:3306/mydatabase";

String username = "myuser";
String password = "mypassword";

try (Connection connection = [Link](url, username, password);

Statement statement = [Link]()) {

String sql = "CREATE TABLE IF NOT EXISTS students (id INT PRIMARY KEY, name VARCHAR(255))";
[Link](sql); // Executes the SQL statement
[Link]("Table created/verified successfully!");

} catch (SQLException e) {
[Link]("Error executing query: " + [Link]());
}

15.5 Inserting Data

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
try (Connection connection = [Link](url, username, password);
Statement statement = [Link]()) {

String sql = "INSERT INTO students (id, name) VALUES (1, 'Alice')";
int rowsAffected = [Link](sql);
[Link](rowsAffected + " row(s) inserted.");

} catch (SQLException e) {
[Link]("Error executing query: " + [Link]());
}

15.6 Retrieving Data

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

try (Connection connection = [Link](url, username, password);

Statement statement = [Link]()) {

String sql = "SELECT * FROM students";

ResultSet resultSet = [Link](sql);

while ([Link]()) {
int id = [Link]("id");
String name = [Link]("name");
[Link]("ID: " + id + ", Name: " + name);
}
} catch (SQLException e) {
[Link]("Error executing query: " + [Link]());
}

15.7 Updating Data

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
try (Connection connection = [Link](url, username, password);
Statement statement = [Link]()) {

String sql = "UPDATE students SET name = 'Alicia' WHERE id = 1";

int rowsAffected = [Link](sql);
[Link](rowsAffected + " row(s) updated.");

} catch (SQLException e) {
[Link]("Error executing query: " + [Link]());
}

15.8 Deleting Data

java<button><svg><path></path></svg><span>Copy code</span><span></span></button>
try (Connection connection = [Link](url, username, password);
Statement statement = [Link]()) {

String sql = "DELETE FROM students WHERE id = 1";

int rowsAffected = [Link](sql);
[Link](rowsAffected + " row(s) deleted.");

} catch (SQLException e) {
[Link]("Error executing query: " + [Link]());
}

15.9 Closing Resources

It's crucial to close database connections, statements, and result sets to release resources. The "try-with-
resources" statement (shown in the examples) automatically closes these resources.

Note: Error Handling should be robust for real applications and not just [Link] statements.
 Conclusion:

Java Fundamentals for BCA Students: A Practical Guide, provides a concise and practical introduction to the Java

programming language, specifically designed for students in Bachelor of Computer Applications (BCA) programs. It starts

with fundamental programming concepts and guides readers through setting up their development environment. It

covers core Java elements, including variables, data types, operators, control flow statements (decision-making and

loops), and Object-Oriented Programming (OOP) principles like objects, classes, methods, inheritance, and

polymorphism. Essential data structures like arrays and strings are explained in detail. Furthermore, it introduces

exception handling for robust code, input/output streams for data handling, and a brief overview of GUI programming

with Swing. It also touches upon collections for efficient data management, multithreading basics for concurrent

programming, and an introduction to Java Database Connectivity (JDBC) for database interaction. Due to the length

constraint, it also focuses on the core essentials, providing practical examples and exercises to build a solid foundation

for further learning in Java.

*****************