4: Array Variable

public class ArrayVariable {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5}; // Declaring and initializing an array variable
        System.out.print("Numbers: ");
        for (int num : numbers) {
            System.out.print(num + " "); // Output: Numbers: 1 2 3 4 5
        }
    }
}

5: Double Variable

public class DoubleVariable {
    public static void main(String[] args) {
        double price = 19.99; // Declaring and initializing a double variable
        System.out.println("Price: " + price); // Output: Price: 19.99
    }
}

6: Character Variable

public class CharVariable {
    public static void main(String[] args) {
        char grade = 'A'; // Declaring and initializing a character variable
        System.out.println("Grade: " + grade); // Output: Grade: A
    }
}

7: Float Variable

public class FloatVariable {
    public static void main(String[] args) {
        float pi = 3.14f; // Declaring and initializing a float variable
        System.out.println("Pi: " + pi); // Output: Pi: 3.14
    }
}

8: Long Variable

public class LongVariable {
    public static void main(String[] args) {
        long distance = 100000000L; // Declaring and initializing a long variable
        System.out.println("Distance: " + distance); // Output: Distance: 100000000
    }
}

Datatypes

A. Primitive - B. Non-Primitive

(A) Primitive Data Types

1. byte || Size: 8 bits || Range: -128 to 127

Example:

byte b = 100;
System.out.println("byte: " + b);

2. short || Size: 16 bits || Range: -32,768 to 32,767

Example:

short s = 10000;
System.out.println("short: " + s);

3. int || Size: 32 bits || Range: -2^31 to 2^31-1

Example:

int i = 100000;
System.out.println("int: " + i);

4. long || Size: 64 bits || Range: -2^63 to 2^63-1

Example:

long l = 100000L;
System.out.println("long: " + l);

5. float || Size: 32 bits || Single-precision floating point

Example:

float f = 5.75f;
System.out.println("float: " + f);

6. double || Size: 64 bits || Double-precision floating point

Example:

double d = 19.99;
System.out.println("double: " + d);

7. boolean || Size: Varies (depends on JVM implementation) || Values: true or false

Example:

boolean isJavaFun = true;
System.out.println("boolean: " + isJavaFun);

8. char

Size: 16 bits

Single Unicode character

Example:

char letter = 'A';
System.out.println("char: " + letter);

(B) Non-Primitive Data Types

1. String

A sequence of characters

Example:

String greeting = "Hello, World!";
System.out.println("String: " + greeting);

2. Array

A collection of elements of the same type

Example:

int[] numbers = {1, 2, 3, 4, 5};
for (int num : numbers) {
    System.out.println("Array element: " + num);
}

Operators

1. Arithmetic Operators:

Used to perform basic arithmetic operations.

int a = 10;
int b = 5;
System.out.println("Addition: " + (a + b)); // 15
System.out.println("Subtraction: " + (a - b)); // 5
System.out.println("Multiplication: " + (a * b)); // 50
System.out.println("Division: " + (a / b)); // 2
System.out.println("Modulus: " + (a % b)); // 0

2. Relational Operators:

Used to compare two values.

int a = 10;
int b = 5;
System.out.println("Equal: " + (a == b)); // false
System.out.println("Not Equal: " + (a != b)); // true
System.out.println("Greater Than: " + (a > b)); // true
System.out.println("Less Than: " + (a < b)); // false
System.out.println("Greater Than or Equal To: " + (a >= b)); // true
System.out.println("Less Than or Equal To: " + (a <= b)); // false

3. Logical Operators:

Used to perform logical operations.

boolean x = true;
boolean y = false;
System.out.println("AND: " + (x && y)); // false
System.out.println("OR: " + (x || y)); // true
System.out.println("NOT: " + (!x)); // false

4. Assignment Operators:

Used to assign values to variables.

int a = 10;
a += 5; // a = a + 5
System.out.println("a += 5: " + a); // 15
a -= 3; // a = a - 3
System.out.println("a -= 3: " + a); // 12
a *= 2; // a = a * 2
System.out.println("a *= 2: " + a); // 24
a /= 4; // a = a / 4
System.out.println("a /= 4: " + a); // 6
a %= 2; // a = a % 2
System.out.println("a %= 2: " + a); // 0

5. Increment and Decrement Operators:

Used to increment or decrement the value of a variable.

int a = 10;
System.out.println("Original Value: " + a); // 10
System.out.println("Post Increment: " + (a++)); // 10
System.out.println("After Post Increment: " + a); // 11
System.out.println("Pre Increment: " + (++a)); // 12
System.out.println("Post Decrement: " + (a--)); // 12
System.out.println("After Post Decrement: " + a); // 11
System.out.println("Pre Decrement: " + (--a)); // 10

6. Ternary Operator

The ternary operator in Java is a shorthand for the if-else statement. It is also known as the conditional operator. It allows you to make decisions in a compact way.

condition ? expression1 : expression2

If the condition is true, expression1 is executed. If the condition is false, expression2 is executed.

Example Here is an example to illustrate the use of the ternary operator:

public class TernaryOperatorExample {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        
        // Using the ternary operator
        int max = (a > b) ? a : b;
        
        System.out.println("The maximum value is: " + max);
    }
}

7.1 Increment Operator (++)

The increment operator adds one to the value of a variable.

public class Main {
    public static void main(String[] args) {
        int a = 5;
        a++; // Post-increment: a is now 6
        System.out.println(a); // Output: 6

        int b = 5;
        ++b; // Pre-increment: b is now 6
        System.out.println(b); // Output: 6
    }
}

7.2 Decrement Operator (--)

The decrement operator subtracts one from the value of a variable.

public class Main {
    public static void main(String[] args) {
        int x = 5;
        x--; // Post-decrement: x is now 4
        System.out.println(x); // Output: 4

        int y = 5;
        --y; // Pre-decrement: y is now 4
        System.out.println(y); // Output: 4
    }
}

Post-Increment/Decrement (a++, x--): The value is used in the expression first, and then incremented or decremented.

Pre-Increment/Decrement (++b, --y): The value is incremented or decremented first, and then used in the expression.

if-else Statement

The if-else statement allows you to execute a block of code based on a condition.

int age = 18;

if (age >= 18) {
    System.out.println("You are an adult.");
} else {
    System.out.println("You are not an adult.");
}

The if-else if-else ladder allows you to test multiple conditions.

int score = 75;

if (score >= 90) {
    System.out.println("Grade: A");
} else if (score >= 80) {
    System.out.println("Grade: B");
} else if (score >= 70) {
    System.out.println("Grade: C");
} else if (score >= 60) {
    System.out.println("Grade: D");
} else {
    System.out.println("Grade: F");
}

switch Statement

The switch statement allows you to execute a block of code based on the value of a variable.

int day = 3;

switch (day) {
    case 1:
        System.out.println("Monday");
        break;
    case 2:
        System.out.println("Tuesday");
        break;
    case 3:
        System.out.println("Wednesday");
        break;
    case 4:
        System.out.println("Thursday");
        break;
    case 5:
        System.out.println("Friday");
        break;
    case 6:
        System.out.println("Saturday");
        break;
    case 7:
        System.out.println("Sunday");
        break;
    default:
        System.out.println("Invalid day");
        break;
}

Sorting Algorithms in Java

Bubble Sort

public class BubbleSort {
    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    // Swap arr[j] and arr[j+1]
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        bubbleSort(arr);
        System.out.println("Sorted array:");
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }
}

Quick Sort

public class QuickSort {
    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int pi = partition(arr, low, high);
            quickSort(arr, low, pi - 1);
            quickSort(arr, pi + 1, high);
        }
    }

    private static int partition(int[] arr, int low, int high) {
        int pivot = arr[high];
        int i = low - 1;
        for (int j = low; j < high; j++) {
            if (arr[j] < pivot) {
                i++;
                // Swap arr[i] and arr[j]
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        // Swap arr[i+1] and arr[high] (pivot)
        int temp = arr[i + 1];
        arr[i + 1] = arr[high];
        arr[high] = temp;
        return i + 1;
    }

    public static void main(String[] args) {
        int[] arr = {10, 7, 8, 9, 1, 5};
        quickSort(arr, 0, arr.length - 1);
        System.out.println("Sorted array:");
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }
}

Object-Oriented Programming Concepts

Classes and Objects

class Dog {
    // Fields (attributes)
    String name;
    int age;

    // Constructor
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Method
    public void bark() {
        System.out.p

This project is a simple yet robust Banking System application developed in Java that demonstrates core object-oriented programming concepts along with advanced features like Exception Handling, Collections Framework, and Generics.