sahello 0.2.5__py3-none-any.whl

sa/__init__.py

@@ -0,0 +1,2236 @@
+def hello():
+    print("""Experiment 1: Control Structures, Arrays, and String Methods 
+import java.util.Scanner;
+public class Experiment1 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        System.out.println("===== PART A: CONTROL STRUCTURES =====");
+        System.out.print("Enter marks (0-100): ");
+        int marks = sc.nextInt();
+        char grade;
+        if (marks >= 90 && marks <= 100) {
+            grade = 'A';
+        } else if (marks >= 80 && marks < 90) {
+            grade = 'B';
+        } else if (marks >= 70 && marks < 80) {
+            grade = 'C';
+        } else if (marks >= 60 && marks < 70) {
+            grade = 'D';
+        } else if (marks >= 0 && marks < 60) {
+            grade = 'F';
+        } else {
+            grade = 'X'; // Invalid
+        }
+        switch (grade) {
+            case 'A':
+                System.out.println("Grade: A - Excellent!");
+                break;
+            case 'B':
+                System.out.println("Grade: B - Very Good!");
+                break;
+            case 'C':
+                System.out.println("Grade: C - Good");
+                break;
+            case 'D':
+                System.out.println("Grade: D - Satisfactory");
+                break;
+            case 'F':
+                System.out.println("Grade: F - Fail");
+                break;
+            default:
+                System.out.println("Invalid marks entered!");
+        }
+        System.out.println("\n===== PART B: ARRAYS =====");
+        int[] numbers = {45, 78, 12, 89, 34, 56, 23, 90, 67, 11};
+        System.out.print("Array elements: ");
+        int sum = 0, max = numbers[0], min = numbers[0];
+        for (int num : numbers) {
+            System.out.print(num + " ");
+            sum += num;
+            if (num > max) max = num;
+            if (num < min) min = num;
+        }
+        System.out.println("\nSum: " + sum);
+        System.out.println("Average: " + (double) sum / numbers.length);
+        System.out.println("Maximum: " + max);
+        System.out.println("Minimum: " + min);
+        System.out.println("\n===== PART C: STRING METHODS =====");
+        String str1 = "Hello World";
+        String str2 = "  Java Programming  ";
+        String str3 = "hello world";
+        System.out.println("Original String: \"" + str1 + "\"");
+        System.out.println("Length: " + str1.length());
+        System.out.println("Character at index 4: " + str1.charAt(4));
+        System.out.println("Substring (0,5): " + str1.substring(0, 5));
+        System.out.println("Uppercase: " + str1.toUpperCase());
+        System.out.println("Lowercase: " + str1.toLowerCase());
+        System.out.println("Replace 'o' with '0': " + str1.replace('o', '0'));
+        System.out.println("Index of 'World': " + str1.indexOf("World"));
+        System.out.println("Starts with 'Hello': " + str1.startsWith("Hello"));
+        System.out.println("Ends with 'World': " + str1.endsWith("World"));
+        System.out.println("Equals (case-sensitive): " + str1.equals(str3));
+        System.out.println("Equals (ignore case): " + str1.equalsIgnoreCase(str3));
+        System.out.println("Trimmed string: \"" + str2.trim() + "\"");
+        System.out.println("Concatenation: " + str1.concat(" - Java"));
+        System.out.println("Split by space: ");
+        String[] words = str1.split(" ");
+        for (int i = 0; i < words.length; i++) {
+            System.out.println("  Word " + (i + 1) + ": " + words[i]);
+        }
+        sc.close();
+    }
+}
+Experiment 2: super, this Keywords, and Constructors 
+public class Experiment2 {
+    public static void main(String[] args) {
+        System.out.println("===== CREATING OBJECTS WITH DIFFERENT CONSTRUCTORS =====\n");
+        System.out.println("1. Creating Student with default constructor:");
+        Student s1 = new Student();
+        System.out.println();
+        System.out.println("2. Creating Student with parameterized constructor:");
+        Student s2 = new Student("Alice Johnson", 20, "STU001", "Computer Science");
+        System.out.println();
+        System.out.println("3. Creating Student with copy constructor:");
+        Student s3 = new Student(s2);
+        System.out.println();
+        System.out.println("===== DISPLAYING STUDENT DETAILS =====\n");
+        System.out.println("Student 1 (Default):");
+        s1.display();
+        System.out.println("\nStudent 2 (Parameterized):");
+        s2.display();
+        System.out.println("\nStudent 3 (Copy of Student 2):");
+        s3.display();
+        s2.showThisUsage();
+        System.out.println("\n===== CREATING PARENT CLASS OBJECT =====");
+        Person p1 = new Person("Bob Smith", 45);
+        System.out.println("\nPerson details:");
+        p1.display();
+    }
+}
+class Person {
+    protected String name;
+    protected int age;
+    public Person() {
+        this.name = "Unknown";
+        this.age = 0;
+        System.out.println("Person: Default constructor called");
+    }
+    public Person(String name, int age) {
+        this.name = name;
+        this.age = age;
+        System.out.println("Person: Parameterized constructor called");
+    }
+    public Person(Person p) {
+        this.name = p.name;
+        this.age = p.age;
+        System.out.println("Person: Copy constructor called");
+    }
+    public void display() {
+        System.out.println("Name: " + name + ", Age: " + age);
+    }
+}
+class Student extends Person {
+    private String studentId;
+    private String course;
+    public Student() {
+        this("Unknown", 0, "N/A", "N/A");
+        System.out.println("Student: Default constructor called");
+    }
+    public Student(String name, int age, String studentId, String course) {
+        super(name, age);
+        this.studentId = studentId;
+        this.course = course;
+        System.out.println("Student: Parameterized constructor called");
+    }
+    public Student(Student s) {
+        super(s);
+        this.studentId = s.studentId;
+        this.course = s.course;
+        System.out.println("Student: Copy constructor called");
+    }
+    public Student getSelf() {
+        return this;
+    }
+    @Override
+    public void display() {
+        super.display();
+        System.out.println("Student ID: " + studentId + ", Course: " + course);
+    }
+    public void showThisUsage() {
+        System.out.println("\n--- Demonstrating 'this' keyword ---");
+        System.out.println("this.name: " + this.name);
+        System.out.println("this.studentId: " + this.studentId);
+        System.out.println("this.getSelf() returns: " + this.getSelf());
+        System.out.println("Current object hashcode: " + this.hashCode());
+    }
+}
+Experiment 3: Method Overloading 
+public class Experiment3 {
+    public static void main(String[] args) {
+        System.out.println("===== CALCULATOR - METHOD OVERLOADING =====\n");
+        Calculator calc = new Calculator();
+        System.out.println("--- Overloading by Number of Parameters ---");
+        System.out.println("Result: " + calc.add(10, 20));
+        System.out.println("Result: " + calc.add(10, 20, 30));
+        System.out.println("Result: " + calc.add(10, 20, 30, 40));
+        System.out.println("\n--- Overloading by Type of Parameters ---");
+        System.out.println("Result: " + calc.add(10.5, 20.5));
+        System.out.println("Result: " + calc.add(5.5f, 4.5f));
+        System.out.println("Result: " + calc.add("Hello", " World"));
+        System.out.println("\n--- Overloading by Order of Parameters ---");
+        System.out.println("Result: " + calc.add("Value: ", 100));
+        System.out.println("Result: " + calc.add(200, " is the number"));
+        System.out.println("\n--- Multiply Operations ---");
+        System.out.println("multiply(5, 3) = " + calc.multiply(5, 3));
+        System.out.println("multiply(2.5, 4.0) = " + calc.multiply(2.5, 4.0));
+        System.out.println("multiply(2, 3, 4) = " + calc.multiply(2, 3, 4));
+        System.out.println("\n===== AREA CALCULATOR - METHOD OVERLOADING =====\n");
+        AreaCalculator area = new AreaCalculator();
+        System.out.printf("Area = %.2f sq units%n%n", area.calculateArea(7.0));
+        System.out.printf("Area = %.2f sq units%n%n", area.calculateArea(10.0, 5.0));
+        System.out.printf("Area = %.2f sq units%n%n", area.calculateArea(8.0, 6.0, "triangle"));
+        System.out.printf("Area = %.2f sq units%n%n", area.calculateArea(5));
+        System.out.println("===== DISPLAY HELPER - METHOD OVERLOADING =====\n");
+        DisplayHelper dh = new DisplayHelper();
+        dh.display(42);
+        dh.display(3.14159);
+        dh.display("Hello Java!");
+        dh.display(new int[]{1, 2, 3, 4, 5});
+        System.out.println();
+        dh.display("Java is awesome!", 3);
+    }
+}
+class Calculator {
+    public int add(int a, int b) {
+        System.out.println("add(int, int) called");
+        return a + b;
+    }
+    public int add(int a, int b, int c) {
+        System.out.println("add(int, int, int) called");
+        return a + b + c;
+    }
+    public int add(int a, int b, int c, int d) {
+        System.out.println("add(int, int, int, int) called");
+        return a + b + c + d;
+    }
+    public double add(double a, double b) {
+        System.out.println("add(double, double) called");
+        return a + b;
+    }
+    public float add(float a, float b) {
+        System.out.println("add(float, float) called");
+        return a + b;
+    }
+    public String add(String a, String b) {
+        System.out.println("add(String, String) called");
+        return a + b;
+    }
+    public String add(String str, int num) {
+        System.out.println("add(String, int) called");
+        return str + num;
+    }
+    public String add(int num, String str) {
+        System.out.println("add(int, String) called");
+        return num + str;
+    }
+    public int multiply(int a, int b) {
+        return a * b;
+    }
+    public double multiply(double a, double b) {
+        return a * b;
+    }
+    public int multiply(int a, int b, int c) {
+        return a * b * c;
+    }
+}
+class AreaCalculator {
+    public double calculateArea(double radius) {
+        System.out.println("Calculating area of Circle");
+        return Math.PI * radius * radius;
+    }
+    public double calculateArea(double length, double breadth) {
+        System.out.println("Calculating area of Rectangle");
+        return length * breadth;
+    }
+    public double calculateArea(double base, double height, String shape) {
+        if (shape.equalsIgnoreCase("triangle")) {
+            System.out.println("Calculating area of Triangle");
+            return 0.5 * base * height;
+        }
+        return 0;
+    }
+    public double calculateArea(int side) {
+        System.out.println("Calculating area of Square");
+        return side * side;
+    }
+}
+class DisplayHelper {
+    public void display(int value) {
+        System.out.println("Integer value: " + value);
+    }
+    public void display(double value) {
+        System.out.println("Double value: " + value);
+    }
+    public void display(String value) {
+        System.out.println("String value: " + value);
+    }
+    public void display(int[] arr) {
+        System.out.print("Array values: ");
+        for (int num : arr) {
+            System.out.print(num + " ");
+        }
+        System.out.println();
+    }
+    public void display(String message, int times) {
+        System.out.println("Repeating message " + times + " times:");
+        for (int i = 0; i < times; i++) {
+            System.out.println("  " + (i + 1) + ". " + message);
+        }
+    }
+}
+Experiment 4: Single, Multilevel, Hierarchical, and Hybrid Inheritance
+public class Experiment4 {
+    public static void main(String[] args) {
+        System.out.println("========== SINGLE INHERITANCE ==========");
+        System.out.println("(Animal -> Dog)\n");
+        Dog dog = new Dog("Buddy", "Golden Retriever");
+        dog.displayInfo();
+        dog.eat();
+        dog.sleep();
+        dog.bark();
+        System.out.println("\n========== MULTILEVEL INHERITANCE ==========");
+        System.out.println("(LivingBeing -> Human -> Employee)\n");
+        Employee emp = new Employee("John Doe", "EMP001", "Engineering");
+        emp.displayDetails();
+        emp.breathe();
+        emp.speak();
+        emp.work();
+        System.out.println("\n========== HIERARCHICAL INHERITANCE ==========");
+        System.out.println("(Shape -> Circle, Rectangle, Triangle)\n");
+        Circle circle = new Circle("Red", 5.0);
+        circle.display();
+        System.out.println();
+        Rectangle rect = new Rectangle("Blue", 10.0, 6.0);
+        rect.display();
+        System.out.println();
+        Triangle tri = new Triangle("Green", 8.0, 5.0);
+        tri.display();
+        System.out.println("\n========== HYBRID INHERITANCE ==========");
+        System.out.println("(Machine + Printable/Scannable interfaces)\n");
+        System.out.println("--- Printer ---");
+        Printer printer = new Printer("HP", "LaserJet Pro");
+        printer.powerOn();
+        printer.print();
+        printer.powerOff();
+        System.out.println("\n--- Scanner ---");
+        Scanner scanner = new Scanner("Canon", "CanoScan LiDE");
+        scanner.powerOn();
+        scanner.scan();
+        scanner.powerOff();
+        System.out.println("\n--- All-in-One Printer ---");
+        AllInOnePrinter allinone = new AllInOnePrinter("Epson", "EcoTank ET-4850");
+        allinone.powerOn();
+        allinone.print();
+        allinone.scan();
+        allinone.copy();
+        allinone.powerOff();
+    }
+}
+class Animal {
+    String name;
+    public void eat() {
+        System.out.println(name + " is eating.");
+    }
+    public void sleep() {
+        System.out.println(name + " is sleeping.");
+    }
+}
+class Dog extends Animal {
+    String breed;
+    public Dog(String name, String breed) {
+        this.name = name;
+        this.breed = breed;
+    }
+    public void bark() {
+        System.out.println(name + " is barking!");
+    }
+    public void displayInfo() {
+        System.out.println("Name: " + name + ", Breed: " + breed);
+    }
+}
+class LivingBeing {
+    public void breathe() {
+        System.out.println("Breathing...");
+    }
+}
+class Human extends LivingBeing {
+    String name;
+    public Human(String name) {
+        this.name = name;
+    }
+    public void speak() {
+        System.out.println(name + " is speaking.");
+    }
+}
+class Employee extends Human {
+    String employeeId;
+    String department;
+    public Employee(String name, String employeeId, String department) {
+        super(name);
+        this.employeeId = employeeId;
+        this.department = department;
+    }
+    public void work() {
+        System.out.println(name + " is working in " + department + " department.");
+    }
+    public void displayDetails() {
+        System.out.println("Employee: " + name + " | ID: " + employeeId + " | Dept: " + department);
+    }
+}
+class Shape {
+    String color;
+    public Shape(String color) {
+        this.color = color;
+    }
+    public void displayColor() {
+        System.out.println("Color: " + color);
+    }
+    public double calculateArea() {
+        return 0;
+    }
+}
+class Circle extends Shape {
+    double radius;
+    public Circle(String color, double radius) {
+        super(color);
+        this.radius = radius;
+    }
+    @Override
+    public double calculateArea() {
+        return Math.PI * radius * radius;
+    }
+    public void display() {
+        System.out.println("Circle - Radius: " + radius);
+        displayColor();
+        System.out.printf("Area: %.2f%n", calculateArea());
+    }
+}
+class Rectangle extends Shape {
+    double length, width;
+    public Rectangle(String color, double length, double width) {
+        super(color);
+        this.length = length;
+        this.width = width;
+    }
+    @Override
+    public double calculateArea() {
+        return length * width;
+    }
+    public void display() {
+        System.out.println("Rectangle - Length: " + length + ", Width: " + width);
+        displayColor();
+        System.out.printf("Area: %.2f%n", calculateArea());
+    }
+}
+class Triangle extends Shape {
+    double base, height;
+    public Triangle(String color, double base, double height) {
+        super(color);
+        this.base = base;
+        this.height = height;
+    }
+    @Override
+    public double calculateArea() {
+        return 0.5 * base * height;
+    }
+    public void display() {
+        System.out.println("Triangle - Base: " + base + ", Height: " + height);
+        displayColor();
+        System.out.printf("Area: %.2f%n", calculateArea());
+    }
+}
+interface Printable {
+    void print();
+}
+interface Scannable {
+    void scan();
+}
+class Machine {
+    String brand;
+    String model;
+    public Machine(String brand, String model) {
+        this.brand = brand;
+        this.model = model;
+    }
+    public void powerOn() {
+        System.out.println(brand + " " + model + " is powered ON.");
+    }
+    public void powerOff() {
+        System.out.println(brand + " " + model + " is powered OFF.");
+    }
+}
+class Printer extends Machine implements Printable {
+    public Printer(String brand, String model) {
+        super(brand, model);
+    }
+    @Override
+    public void print() {
+        System.out.println("Printing document using " + brand + " " + model);
+    }
+}
+class Scanner extends Machine implements Scannable {
+    public Scanner(String brand, String model) {
+        super(brand, model);
+    }
+    @Override
+    public void scan() {
+        System.out.println("Scanning document using " + brand + " " + model);
+    }
+}
+class AllInOnePrinter extends Machine implements Printable, Scannable {
+    public AllInOnePrinter(String brand, String model) {
+        super(brand, model);
+    }
+    @Override
+    public void print() {
+        System.out.println("Printing using All-in-One: " + brand + " " + model);
+    }
+    @Override
+    public void scan() {
+        System.out.println("Scanning using All-in-One: " + brand + " " + model);
+    }
+    public void copy() {
+        System.out.println("Copying document using " + brand + " " + model);
+    }
+}
+Experiment 5: Packages
+mathoperations/BasicMath.java
+package mathoperations;
+public class BasicMath {
+    public int add(int a, int b) {
+        return a + b;
+    }
+    public int subtract(int a, int b) {
+        return a - b;
+    }
+    public int multiply(int a, int b) {
+        return a * b;
+    }
+    public double divide(int a, int b) {
+        if (b == 0) {
+            throw new ArithmeticException("Cannot divide by zero");
+        }
+        return (double) a / b;
+    }
+}
+mathoperations/AdvancedMath.java
+package mathoperations;
+public class AdvancedMath {
+    public double power(double base, double exponent) {
+        return Math.pow(base, exponent);
+    }
+    public double squareRoot(double number) {
+        if (number < 0) {
+            throw new IllegalArgumentException("Cannot calculate square root of negative number");
+        }
+        return Math.sqrt(number);
+    }
+    public long factorial(int n) {
+        if (n < 0) {
+            throw new IllegalArgumentException("Factorial not defined for negative numbers");
+        }
+        long result = 1;
+        for (int i = 2; i <= n; i++) {
+            result *= i;
+        }
+        return result;
+    }
+    public boolean isPrime(int n) {
+        if (n <= 1) return false;
+        if (n <= 3) return true;
+        if (n % 2 == 0 || n % 3 == 0) return false;
+        for (int i = 5; i * i <= n; i += 6) {
+            if (n % i == 0 || n % (i + 2) == 0) return false;
+        }
+        return true;
+    }
+}
+utilities/StringHelper.java
+package utilities;
+public class StringHelper {
+    public String reverse(String str) {
+        return new StringBuilder(str).reverse().toString();
+    }
+    public boolean isPalindrome(String str) {
+        String clean = str.replaceAll("\\s+", "").toLowerCase();
+        return clean.equals(new StringBuilder(clean).reverse().toString());
+    }
+    public int countVowels(String str) {
+        int count = 0;
+        String vowels = "aeiouAEIOU";
+        for (char c : str.toCharArray()) {
+            if (vowels.indexOf(c) != -1) {
+                count++;
+            }
+        }
+        return count;
+    }
+    public String toTitleCase(String str) {
+        StringBuilder result = new StringBuilder();
+        boolean capitalizeNext = true;
+        for (char c : str.toCharArray()) {
+            if (Character.isWhitespace(c)) {
+                capitalizeNext = true;
+                result.append(c);
+            } else if (capitalizeNext) {
+                result.append(Character.toUpperCase(c));
+                capitalizeNext = false;
+            } else {
+                result.append(Character.toLowerCase(c));
+            }
+        }
+        return result.toString();
+    }
+}
+utilities/ArrayHelper.java
+package utilities;
+import java.util.Arrays;
+public class ArrayHelper {
+    public int findMax(int[] arr) {
+        int max = arr[0];
+        for (int num : arr) {
+            if (num > max) max = num;
+        }
+        return max;
+    }
+    public int findMin(int[] arr) {
+        int min = arr[0];
+        for (int num : arr) {
+            if (num < min) min = num;
+        }
+        return min;
+    }
+    public double findAverage(int[] arr) {
+        int sum = 0;
+        for (int num : arr) {
+            sum += num;
+        }
+        return (double) sum / arr.length;
+    }
+    public int[] sortArray(int[] arr) {
+        int[] sorted = arr.clone();
+        Arrays.sort(sorted);
+        return sorted;
+    }
+    public int[] reverseArray(int[] arr) {
+        int[] reversed = new int[arr.length];
+        for (int i = 0; i < arr.length; i++) {
+            reversed[i] = arr[arr.length - 1 - i];
+        }
+        return reversed;
+    }
+}
+Experiment5.java
+import mathoperations.BasicMath;
+import mathoperations.AdvancedMath;
+import utilities.*;
+import java.util.Date;
+import java.util.Random;
+import java.text.SimpleDateFormat;
+import java.util.Arrays;
+public class Experiment5 {
+    public static void main(String[] args) {
+        System.out.println("╔════════════════════════════════════════════╗");
+        System.out.println("║     JAVA PACKAGES DEMONSTRATION            ║");
+        System.out.println("╚════════════════════════════════════════════╝\n");
+        System.out.println("===== MATH OPERATIONS PACKAGE =====\n");
+        BasicMath basicMath = new BasicMath();
+        System.out.println("--- Basic Math Operations ---");
+        System.out.println("Addition: 15 + 7 = " + basicMath.add(15, 7));
+        System.out.println("Subtraction: 20 - 8 = " + basicMath.subtract(20, 8));
+        System.out.println("Multiplication: 6 × 9 = " + basicMath.multiply(6, 9));
+        System.out.println("Division: 100 ÷ 8 = " + basicMath.divide(100, 8));
+        System.out.println();
+        AdvancedMath advMath = new AdvancedMath();
+        System.out.println("--- Advanced Math Operations ---");
+        System.out.println("Power: 2^10 = " + (int) advMath.power(2, 10));
+        System.out.println("Square Root: √144 = " + (int) advMath.squareRoot(144));
+        System.out.println("Factorial: 7! = " + advMath.factorial(7));
+        System.out.println("Is 97 Prime? " + advMath.isPrime(97));
+        System.out.println("Is 100 Prime? " + advMath.isPrime(100));
+        System.out.println("\n===== UTILITIES PACKAGE =====\n");
+        StringHelper strHelper = new StringHelper();
+        System.out.println("--- String Helper Operations ---");
+        String testStr = "Hello World";
+        System.out.println("Original: \"" + testStr + "\"");
+        System.out.println("Reversed: \"" + strHelper.reverse(testStr) + "\"");
+        System.out.println("Vowel Count: " + strHelper.countVowels(testStr));
+        System.out.println("Title Case of 'jAVA proGRAMMING': \"" + strHelper.toTitleCase("jAVA proGRAMMING") + "\"");
+        System.out.println("Is 'A man a plan a canal Panama' palindrome? " + strHelper.isPalindrome("A man a plan a canal Panama"));
+        System.out.println();
+        ArrayHelper arrHelper = new ArrayHelper();
+        System.out.println("--- Array Helper Operations ---");
+        int[] numbers = {64, 34, 25, 12, 22, 11, 90};
+        System.out.println("Original Array: " + Arrays.toString(numbers));
+        System.out.println("Maximum: " + arrHelper.findMax(numbers));
+        System.out.println("Minimum: " + arrHelper.findMin(numbers));
+        System.out.printf("Average: %.2f%n", arrHelper.findAverage(numbers));
+        System.out.println("Sorted Array: " + Arrays.toString(arrHelper.sortArray(numbers)));
+        System.out.println("Reversed Array: " + Arrays.toString(arrHelper.reverseArray(numbers)));
+        System.out.println("\n===== BUILT-IN JAVA PACKAGES =====\n");
+        System.out.println("--- java.util.Date and SimpleDateFormat ---");
+        Date currentDate = new Date();
+        SimpleDateFormat sdf = new SimpleDateFormat("EEEE, MMMM dd, yyyy HH:mm:ss");
+        System.out.println("Current Date/Time: " + sdf.format(currentDate));
+        System.out.println();
+        System.out.println("--- java.util.Random ---");
+        Random rand = new Random();
+        System.out.print("5 Random Numbers (1-100): ");
+        for (int i = 0; i < 5; i++) {
+            System.out.print(rand.nextInt(100) + 1);
+            if (i < 4) System.out.print(", ");
+        }
+        System.out.println();
+        System.out.println();
+        System.out.println("--- java.lang.Math (imported by default) ---");
+        System.out.println("PI value: " + Math.PI);
+        System.out.println("E value: " + Math.E);
+        System.out.println("Max(45, 78): " + Math.max(45, 78));
+        System.out.println("Round(4.7): " + Math.round(4.7));
+        System.out.println("Abs(-99): " + Math.abs(-99));
+        System.out.println("\n===== PACKAGE STRUCTURE =====");
+        System.out.println("├── mathoperations/");
+        System.out.println("│   ├── BasicMath.java");
+        System.out.println("│   └── AdvancedMath.java");
+        System.out.println("├── utilities/");
+        System.out.println("│   ├── StringHelper.java");
+        System.out.println("│   └── ArrayHelper.java");
+        System.out.println("└── Experiment5.java (Main)");
+    }
+}
+Experiment 6: Interfaces 
+public class Experiment6 {
+    public static void main(String[] args) {
+        System.out.println("╔════════════════════════════════════════════╗");
+        System.out.println("║        JAVA INTERFACES DEMONSTRATION       ║");
+        System.out.println("╚════════════════════════════════════════════╝\n");
+        System.out.println("===== INTERFACE STATIC METHOD =====");
+        Drawable.info();
+        System.out.println("\n===== SINGLE INTERFACE IMPLEMENTATION =====");
+        SimpleCircle simpleCircle = new SimpleCircle(5.0);
+        simpleCircle.draw();
+        simpleCircle.displayTool();
+        System.out.println("\n===== MULTIPLE INTERFACE IMPLEMENTATION (Rectangle) =====");
+        Rectangle rect = new Rectangle(10, 5);
+        rect.displayDimensions();
+        rect.draw();
+        System.out.printf("Area: %.2f sq units%n", rect.getArea());
+        System.out.printf("Perimeter: %.2f units%n", rect.getPerimeter());
+        rect.shapeInfo();
+        System.out.println();
+        rect.resize(1.5);
+        System.out.printf("New Area: %.2f sq units%n", rect.getArea());
+        System.out.println("\n===== MULTIPLE INTERFACE IMPLEMENTATION (Circle) =====");
+        Circle circle = new Circle(7);
+        circle.displayDimensions();
+        circle.draw();
+        System.out.printf("Area: %.2f sq units%n", circle.getArea());
+        System.out.printf("Perimeter (Circumference): %.2f units%n", circle.getPerimeter());
+        System.out.println("\n===== POLYMORPHISM WITH INTERFACES =====");
+        Shape2D[] shapes = {new Rectangle(8, 4), new Circle(5)};
+        for (Shape2D shape : shapes) {
+            System.out.println("\n--- Shape ---");
+            shape.displayDimensions();
+            System.out.printf("Area: %.2f sq units%n", shape.getArea());
+        }
+        System.out.println("\n===== FUNCTIONAL INTERFACE WITH LAMBDA =====");
+        Calculator add = (a, b) -> a + b;
+        Calculator subtract = (a, b) -> a - b;
+        Calculator multiply = (a, b) -> a * b;
+        Calculator divide = (a, b) -> b != 0 ? a / b : 0;
+        int x = 20, y = 5;
+        System.out.println("Numbers: " + x + " and " + y);
+        System.out.println("Addition: " + add.calculate(x, y));
+        System.out.println("Subtraction: " + subtract.calculate(x, y));
+        System.out.println("Multiplication: " + multiply.calculate(x, y));
+        System.out.println("Division: " + divide.calculate(x, y));
+        System.out.println("\n===== INTERFACE WITH DEFAULT AND PRIVATE METHODS =====");
+        Application app = new Application("MyApp");
+        app.start();
+        app.handleError("Connection timeout occurred");
+        app.stop();
+        System.out.println("\n===== INTERFACE REFERENCE =====");
+        Drawable d = new Circle(3);
+        d.draw();
+        Resizable r = new Rectangle(6, 4);
+        r.resize(2);
+        System.out.printf("Area after resize: %.2f%n", r.getArea());
+    }
+}
+interface Drawable {
+    String DRAWING_TOOL = "Digital Pen";
+    void draw();
+    default void displayTool() {
+        System.out.println("Using: " + DRAWING_TOOL);
+    }
+    static void info() {
+        System.out.println("Drawable interface - Provides drawing capability");
+    }
+}
+interface Resizable {
+    void resize(double factor);
+    double getArea();
+}
+interface Shape2D extends Drawable, Resizable {
+    void displayDimensions();
+    default void shapeInfo() {
+        System.out.println("This is a 2D shape that is drawable and resizable.");
+    }
+}
+interface Perimeter {
+    double getPerimeter();
+}
+class SimpleCircle implements Drawable {
+    private double radius;
+    public SimpleCircle(double radius) {
+        this.radius = radius;
+    }
+    @Override
+    public void draw() {
+        System.out.println("Drawing a simple circle with radius: " + radius);
+    }
+}
+class Rectangle implements Shape2D, Perimeter {
+    private double length;
+    private double width;
+    public Rectangle(double length, double width) {
+        this.length = length;
+        this.width = width;
+    }
+    @Override
+    public void draw() {
+        System.out.println("Drawing Rectangle: " + length + " x " + width);
+        System.out.println("  +---" + "-".repeat((int)length) + "---+");
+        for (int i = 0; i < width / 2; i++) {
+            System.out.println("  |   " + " ".repeat((int)length) + "   |");
+        }
+        System.out.println("  +---" + "-".repeat((int)length) + "---+");
+    }
+    @Override
+    public void resize(double factor) {
+        length *= factor;
+        width *= factor;
+        System.out.println("Rectangle resized by factor " + factor);
+        System.out.println("New dimensions: " + length + " x " + width);
+    }
+    @Override
+    public double getArea() {
+        return length * width;
+    }
+    @Override
+    public double getPerimeter() {
+        return 2 * (length + width);
+    }
+    @Override
+    public void displayDimensions() {
+        System.out.println("Length: " + length + ", Width: " + width);
+    }
+}
+class Circle implements Shape2D, Perimeter {
+    private double radius;
+    public Circle(double radius) {
+        this.radius = radius;
+    }
+    @Override
+    public void draw() {
+        System.out.println("Drawing Circle with radius: " + radius);
+        System.out.println("      ***");
+        System.out.println("    *     *");
+        System.out.println("   *       *");
+        System.out.println("   *       *");
+        System.out.println("    *     *");
+        System.out.println("      ***");
+    }
+    @Override
+    public void resize(double factor) {
+        radius *= factor;
+        System.out.println("Circle resized by factor " + factor);
+        System.out.println("New radius: " + radius);
+    }
+    @Override
+    public double getArea() {
+        return Math.PI * radius * radius;
+    }
+    @Override
+    public double getPerimeter() {
+        return 2 * Math.PI * radius;
+    }
+    @Override
+    public void displayDimensions() {
+        System.out.println("Radius: " + radius);
+    }
+}
+@FunctionalInterface
+interface Calculator {
+    int calculate(int a, int b);
+}
+interface Logger {
+    default void logInfo(String message) {
+        log("INFO", message);
+    }
+    default void logError(String message) {
+        log("ERROR", message);
+    }
+    private void log(String level, String message) {
+        System.out.println("[" + level + "] " + message);
+    }
+}
+class Application implements Logger {
+    private String name;
+    public Application(String name) {
+        this.name = name;
+    }
+    public void start() {
+        logInfo(name + " application started");
+    }
+    public void stop() {
+        logInfo(name + " application stopped");
+    }
+    public void handleError(String error) {
+        logError(error);
+    }
+}
+Experiment 7: Exception Handling 
+import java.util.Scanner;
+import java.util.InputMismatchException;
+import java.io.*;
+public class Experiment7 {
+public static int divide(int a, int b) throws ArithmeticException {
+if (b == 0) {
+throw new ArithmeticException("Division by zero is not allowed");
+}
+return a / b;
+}
+public static void readFile(String filename) throws FileNotFoundException, IOException {
+FileReader fr = null;
+BufferedReader br = null;
+try {
+fr = new FileReader(filename);
+br = new BufferedReader(fr);
+String line;
+System.out.println("File contents:");
+while ((line = br.readLine()) != null) {
+System.out.println(line);
+}
+} finally {
+if (br != null) br.close();
+if (fr != null) fr.close();
+}
+}
+public static void validateAge(int age) {
+if (age < 0) {
+throw new IllegalArgumentException("Age cannot be negative");
+} else if (age < 18) {
+throw new IllegalArgumentException("Age must be 18 or above");
+}
+System.out.println("Age " + age + " is valid. Access granted!");
+}
+public static void methodA() throws Exception {
+System.out.println("Inside methodA");
+methodB();
+}
+public static void methodB() throws Exception {
+System.out.println("Inside methodB");
+methodC();
+}
+public static void methodC() throws Exception {
+System.out.println("Inside methodC");
+throw new Exception("Exception thrown from methodC");
+}
+public static void tryWithResourcesDemo() {
+System.out.println("\n--- Try-With-Resources Demo ---");
+String data = "Hello, Java Exception Handling!";
+try (FileWriter fw = new FileWriter("test_output.txt");
+BufferedWriter bw = new BufferedWriter(fw)) {
+bw.write(data);
+System.out.println("Data written to file successfully");
+} catch (IOException e) {
+System.out.println("Error writing to file: " + e.getMessage());
+}
+try (FileReader fr = new FileReader("test_output.txt");
+BufferedReader br = new BufferedReader(fr)) {
+String line = br.readLine();
+System.out.println("Data read from file: " + line);
+} catch (IOException e) {
+System.out.println("Error reading file: " + e.getMessage());
+}
+new File("test_output.txt").delete();
+}
+public static void main(String[] args) {
+Scanner sc = new Scanner(System.in);
+System.out.println("╔════════════════════════════════════════════╗");
+System.out.println("║     EXCEPTION HANDLING IN JAVA             ║");
+System.out.println("╚════════════════════════════════════════════╝\n");
+System.out.println("===== 1. BASIC TRY-CATCH =====");
+try {
+int[] arr = {1, 2, 3};
+System.out.println("Accessing index 5: " + arr[5]);
+} catch (ArrayIndexOutOfBoundsException e) {
+System.out.println("Exception caught: " + e.getClass().getSimpleName());
+System.out.println("Message: " + e.getMessage());
+}
+System.out.println("\n===== 2. MULTIPLE CATCH BLOCKS =====");
+try {
+int[] numbers = {10, 20, 30, 0, 50};
+int index = 2;
+System.out.println("Value at index " + index + ": " + numbers[index]);
+int result = numbers[index] / numbers[3];
+System.out.println("Result: " + result);
+} catch (ArrayIndexOutOfBoundsException e) {
+System.out.println("Array index error: " + e.getMessage());
+} catch (ArithmeticException e) {
+System.out.println("Arithmetic error: " + e.getMessage());
+} catch (Exception e) {
+System.out.println("General exception: " + e.getMessage());
+}
+System.out.println("\n===== 3. TRY-CATCH-FINALLY =====");
+FileWriter writer = null;
+try {
+System.out.println("Attempting to open file...");
+writer = new FileWriter("temp.txt");
+System.out.println("File opened successfully");
+writer.write("Test data");
+System.out.println("Data written");
+int x = 10 / 0;
+} catch (IOException e) {
+System.out.println("IO Exception: " + e.getMessage());
+} catch (ArithmeticException e) {
+System.out.println("Arithmetic Exception: " + e.getMessage());
+} finally {
+System.out.println("Finally block executed - Cleaning up resources");
+try {
+if (writer != null) {
+writer.close();
+System.out.println("File closed successfully");
+}
+} catch (IOException e) {
+System.out.println("Error closing file");
+}
+new File("temp.txt").delete();
+}
+System.out.println("\n===== 4. THROW KEYWORD =====");
+int[] testAges = {25, -5, 15, 30};
+for (int age : testAges) {
+try {
+System.out.print("Validating age " + age + ": ");
+validateAge(age);
+} catch (IllegalArgumentException e) {
+System.out.println("Error - " + e.getMessage());
+}
+}
+System.out.println("\n===== 5. THROWS KEYWORD =====");
+try {
+System.out.println("20 / 4 = " + divide(20, 4));
+System.out.println("15 / 0 = " + divide(15, 0));
+} catch (ArithmeticException e) {
+System.out.println("Exception caught: " + e.getMessage());
+}
+System.out.println("\n===== 6. NESTED TRY-CATCH =====");
+try {
+System.out.println("Outer try block");
+try {
+System.out.println("Inner try block");
+String str = null;
+System.out.println(str.length());
+} catch (NullPointerException e) {
+System.out.println("Inner catch: NullPointerException caught");
+}
+int[] arr = new int[3];
+arr[5] = 100;
+} catch (ArrayIndexOutOfBoundsException e) {
+System.out.println("Outer catch: ArrayIndexOutOfBoundsException caught");
+}
+System.out.println("\n===== 7. EXCEPTION PROPAGATION =====");
+try {
+methodA();
+} catch (Exception e) {
+System.out.println("Exception caught in main: " + e.getMessage());
+System.out.println("Stack trace:");
+for (StackTraceElement element : e.getStackTrace()) {
+System.out.println("  at " + element);
+}
+}
+System.out.println("\n===== 8. MULTI-CATCH BLOCK =====");
+try {
+String numStr = "abc";
+int num = Integer.parseInt(numStr);
+int[] arr = new int[2];
+arr[5] = num;
+} catch (NumberFormatException | ArrayIndexOutOfBoundsException e) {
+System.out.println("Caught exception: " + e.getClass().getSimpleName());
+System.out.println("Message: " + e.getMessage());
+}
+tryWithResourcesDemo();
+System.out.println("\n===== 10. COMMON RUNTIME EXCEPTIONS =====");
+try {
+String s = null;
+System.out.println(s.toUpperCase());
+} catch (NullPointerException e) {
+System.out.println("✗ NullPointerException: " + e.getMessage());
+}
+try {
+int n = Integer.parseInt("12.34");
+} catch (NumberFormatException e) {
+System.out.println("✗ NumberFormatException: " + e.getMessage());
+}
+try {
+Object obj = Integer.valueOf(10);
+String str = (String) obj;
+} catch (ClassCastException e) {
+System.out.println("✗ ClassCastException: " + e.getMessage());
+}
+System.out.println("\n===== PROGRAM COMPLETED SUCCESSFULLY =====");
+sc.close();
+}
+}
+Experiment 8: ATM Withdrawal with Custom Exception 
+import java.util.Scanner;
+import java.util.InputMismatchException;
+import java.io.*;
+public class Experiment8 {
+public static void main(String[] args) {
+Scanner sc = new Scanner(System.in);
+BankAccount account = new BankAccount("1234567890", "Rahul Sharma", 75000.00, 1234);
+ATM atm = new ATM();
+System.out.println("╔════════════════════════════════════════════╗");
+System.out.println("║   ATM WITHDRAWAL SYSTEM WITH CUSTOM        ║");
+System.out.println("║        EXCEPTION HANDLING                  ║");
+System.out.println("╚════════════════════════════════════════════╝");
+try {
+atm.insertCard(account);
+boolean pinVerified = false;
+while (!pinVerified) {
+System.out.print("\nEnter your 4-digit PIN: ");
+int pin = sc.nextInt();
+try {
+pinVerified = atm.verifyPIN(pin);
+} catch (InvalidPINException e) {
+System.out.println("✗ " + e.getMessage());
+if (e.getRemainingAttempts() > 0) {
+System.out.println("  Remaining attempts: " + e.getRemainingAttempts());
+}
+}
+}
+boolean exit = false;
+while (!exit) {
+System.out.println("\n╔═══════════════════════════════════════╗");
+System.out.println("║            ATM MENU                   ║");
+System.out.println("╠═══════════════════════════════════════╣");
+System.out.println("║  1. Check Balance                     ║");
+System.out.println("║  2. Withdraw Cash                     ║");
+System.out.println("║  3. Deposit Cash                      ║");
+System.out.println("║  4. Exit                              ║");
+System.out.println("╚═══════════════════════════════════════╝");
+System.out.print("Enter your choice: ");
+int choice = sc.nextInt();
+switch (choice) {
+case 1:
+atm.checkBalance();
+break;
+case 2:
+System.out.print("Enter amount to withdraw (multiples of ₹100): ₹");
+double withdrawAmount = sc.nextDouble();
+try {
+atm.withdraw(withdrawAmount);
+} catch (InsufficientBalanceException e) {
+System.out.println("\n✗ TRANSACTION FAILED");
+System.out.println("  " + e.getMessage());
+System.out.println("  Minimum balance of ₹" + account.getMinBalance() + " must be maintained.");
+} catch (DailyLimitExceededException e) {
+System.out.println("\n✗ TRANSACTION FAILED");
+System.out.println("  " + e.getMessage());
+System.out.println("  Daily limit: ₹" + account.getDailyLimit());
+System.out.println("  Remaining limit for today: ₹" + e.getRemainingLimit());
+} catch (InvalidAmountException e) {
+System.out.println("\n✗ INVALID AMOUNT");
+System.out.println("  " + e.getMessage());
+}
+break;
+case 3:
+System.out.print("Enter amount to deposit (multiples of ₹100): ₹");
+double depositAmount = sc.nextDouble();
+try {
+atm.deposit(depositAmount);
+} catch (InvalidAmountException e) {
+System.out.println("\n✗ INVALID AMOUNT");
+System.out.println("  " + e.getMessage());
+}
+break;
+case 4:
+exit = true;
+atm.ejectCard();
+break;
+default:
+System.out.println("Invalid choice. Please try again.");
+}
+}
+} catch (CardBlockedException e) {
+System.out.println("\n╔═══════════════════════════════════════╗");
+System.out.println("║           CARD BLOCKED                ║");
+System.out.println("╠═══════════════════════════════════════╣");
+System.out.println("║  " + e.getMessage());
+System.out.println("╚═══════════════════════════════════════╝");
+}
+System.out.println("\n\n===== DEMONSTRATION OF ALL CUSTOM EXCEPTIONS =====");
+BankAccount demoAccount = new BankAccount("9876543210", "Demo User", 5000.00, 9999);
+ATM demoATM = new ATM();
+try {
+demoATM.insertCard(demoAccount);
+demoATM.verifyPIN(9999);
+System.out.println("\n--- Demo 1: Insufficient Balance ---");
+try {
+demoATM.withdraw(10000);
+} catch (InsufficientBalanceException e) {
+System.out.println("Exception: " + e.getClass().getSimpleName());
+System.out.println("Message: " + e.getMessage());
+}
+System.out.println("\n--- Demo 2: Invalid Amount (not multiple of 100) ---");
+try {
+demoATM.withdraw(1550);
+} catch (InvalidAmountException e) {
+System.out.println("Exception: " + e.getClass().getSimpleName());
+System.out.println("Message: " + e.getMessage());
+}
+System.out.println("\n--- Demo 3: Daily Limit Exceeded ---");
+BankAccount richAccount = new BankAccount("1111222233", "Rich User", 100000.00, 1111);
+ATM richATM = new ATM();
+richATM.insertCard(richAccount);
+richATM.verifyPIN(1111);
+richATM.withdraw(48000);
+System.out.println("\nAttempting to withdraw ₹5000 more...");
+try {
+richATM.withdraw(5000);
+} catch (DailyLimitExceededException e) {
+System.out.println("Exception: " + e.getClass().getSimpleName());
+System.out.println("Message: " + e.getMessage());
+System.out.println("Remaining daily limit: ₹" + e.getRemainingLimit());
+}
+} catch (Exception e) {
+System.out.println("Unexpected error: " + e.getMessage());
+}
+System.out.println("\n--- Demo 4: Card Blocked (3 wrong PIN attempts) ---");
+BankAccount blockedAccount = new BankAccount("4444555566", "Block Test", 10000.00, 1234);
+ATM blockATM = new ATM();
+try {
+blockATM.insertCard(blockedAccount);
+for (int i = 1; i <= 3; i++) {
+try {
+System.out.println("Attempt " + i + ": Entering wrong PIN...");
+blockATM.verifyPIN(0000);
+} catch (InvalidPINException e) {
+System.out.println("  " + e.getMessage());
+}
+}
+} catch (CardBlockedException e) {
+System.out.println("\n" + e.getMessage());
+}
+sc.close();
+}
+}
+class InsufficientBalanceException extends Exception {
+private double currentBalance;
+private double requestedAmount;
+public InsufficientBalanceException(double currentBalance, double requestedAmount) {
+super("Insufficient balance! Available: ₹" + currentBalance + ", Requested: ₹" + requestedAmount);
+this.currentBalance = currentBalance;
+this.requestedAmount = requestedAmount;
+}
+public double getCurrentBalance() {
+return currentBalance;
+}
+public double getRequestedAmount() {
+return requestedAmount;
+}
+}
+class InvalidPINException extends Exception {
+private int attempts;
+private static final int MAX_ATTEMPTS = 3;
+public InvalidPINException(int attempts) {
+super("Invalid PIN! Attempt " + attempts + " of " + MAX_ATTEMPTS);
+this.attempts = attempts;
+}
+public int getAttempts() {
+return attempts;
+}
+public int getRemainingAttempts() {
+return MAX_ATTEMPTS - attempts;
+}
+public boolean isCardBlocked() {
+return attempts >= MAX_ATTEMPTS;
+}
+}
+class DailyLimitExceededException extends Exception {
+private double dailyLimit;
+private double alreadyWithdrawn;
+private double requestedAmount;
+public DailyLimitExceededException(double dailyLimit, double alreadyWithdrawn, double requestedAmount) {
+super("Daily withdrawal limit exceeded!");
+this.dailyLimit = dailyLimit;
+this.alreadyWithdrawn = alreadyWithdrawn;
+this.requestedAmount = requestedAmount;
+}
+public double getRemainingLimit() {
+return dailyLimit - alreadyWithdrawn;
+}
+}
+class InvalidAmountException extends Exception {
+public InvalidAmountException(String message) {
+super(message);
+}
+}
+class CardBlockedException extends Exception {
+public CardBlockedException() {
+super("Your card has been blocked due to multiple incorrect PIN attempts. Please contact your bank.");
+}
+}
+class BankAccount {
+private String accountNumber;
+private String accountHolder;
+private double balance;
+private int pin;
+private double dailyWithdrawn;
+private static final double DAILY_LIMIT = 50000.0;
+private static final double MIN_BALANCE = 1000.0;
+public BankAccount(String accountNumber, String accountHolder, double balance, int pin) {
+this.accountNumber = accountNumber;
+this.accountHolder = accountHolder;
+this.balance = balance;
+this.pin = pin;
+this.dailyWithdrawn = 0;
+}
+public String getAccountNumber() {
+return accountNumber;
+}
+public String getAccountHolder() {
+return accountHolder;
+}
+public double getBalance() {
+return balance;
+}
+public double getDailyWithdrawn() {
+return dailyWithdrawn;
+}
+public double getDailyLimit() {
+return DAILY_LIMIT;
+}
+public double getRemainingDailyLimit() {
+return DAILY_LIMIT - dailyWithdrawn;
+}
+public boolean validatePIN(int enteredPIN) {
+return this.pin == enteredPIN;
+}
+public void withdraw(double amount) {
+this.balance -= amount;
+this.dailyWithdrawn += amount;
+}
+public void deposit(double amount) {
+this.balance += amount;
+}
+public double getMinBalance() {
+return MIN_BALANCE;
+}
+public void resetDailyLimit() {
+this.dailyWithdrawn = 0;
+}
+}
+class ATM {
+private BankAccount currentAccount;
+private int pinAttempts;
+private boolean cardBlocked;
+private static final int MAX_PIN_ATTEMPTS = 3;
+public ATM() {
+this.pinAttempts = 0;
+this.cardBlocked = false;
+}
+public void insertCard(BankAccount account) throws CardBlockedException {
+if (cardBlocked) {
+throw new CardBlockedException();
+}
+this.currentAccount = account;
+this.pinAttempts = 0;
+System.out.println("\n╔═══════════════════════════════════════╗");
+System.out.println("║     Welcome to ABC Bank ATM           ║");
+System.out.println("╚═══════════════════════════════════════╝");
+System.out.println("Card inserted: ****" + account.getAccountNumber().substring(account.getAccountNumber().length() - 4));
+}
+public boolean verifyPIN(int enteredPIN) throws InvalidPINException, CardBlockedException {
+if (cardBlocked) {
+throw new CardBlockedException();
+}
+if (!currentAccount.validatePIN(enteredPIN)) {
+pinAttempts++;
+if (pinAttempts >= MAX_PIN_ATTEMPTS) {
+cardBlocked = true;
+throw new CardBlockedException();
+}
+throw new InvalidPINException(pinAttempts);
+}
+pinAttempts = 0;
+System.out.println("✓ PIN verified successfully!");
+return true;
+}
+public void withdraw(double amount) throws InsufficientBalanceException, DailyLimitExceededException, InvalidAmountException {
+if (amount <= 0) {
+throw new InvalidAmountException("Withdrawal amount must be positive");
+}
+if (amount % 100 != 0) {
+throw new InvalidAmountException("Amount must be in multiples of ₹100. Please enter a valid amount.");
+}
+if (currentAccount.getDailyWithdrawn() + amount > currentAccount.getDailyLimit()) {
+throw new DailyLimitExceededException(currentAccount.getDailyLimit(), currentAccount.getDailyWithdrawn(), amount);
+}
+double availableForWithdrawal = currentAccount.getBalance() - currentAccount.getMinBalance();
+if (amount > availableForWithdrawal) {
+throw new InsufficientBalanceException(availableForWithdrawal, amount);
+}
+currentAccount.withdraw(amount);
+System.out.println("\n╔═══════════════════════════════════════╗");
+System.out.println("║        TRANSACTION SUCCESSFUL         ║");
+System.out.println("╠═══════════════════════════════════════╣");
+System.out.printf("║  Amount Withdrawn: ₹%-18.2f║%n", amount);
+System.out.printf("║  Remaining Balance: ₹%-17.2f║%n", currentAccount.getBalance());
+System.out.printf("║  Daily Limit Left: ₹%-18.2f║%n", currentAccount.getRemainingDailyLimit());
+System.out.println("╚═══════════════════════════════════════╝");
+System.out.println("\nPlease collect your cash.");
+}
+public void checkBalance() {
+System.out.println("\n╔═══════════════════════════════════════╗");
+System.out.println("║          ACCOUNT BALANCE              ║");
+System.out.println("╠═══════════════════════════════════════╣");
+System.out.printf("║  Account Holder: %-21s║%n", currentAccount.getAccountHolder());
+System.out.printf("║  Current Balance: ₹%-19.2f║%n", currentAccount.getBalance());
+System.out.printf("║  Today's Withdrawal: ₹%-16.2f║%n", currentAccount.getDailyWithdrawn());
+System.out.printf("║  Remaining Daily Limit: ₹%-13.2f║%n", currentAccount.getRemainingDailyLimit());
+System.out.println("╚═══════════════════════════════════════╝");
+}
+public void deposit(double amount) throws InvalidAmountException {
+if (amount <= 0) {
+throw new InvalidAmountException("Deposit amount must be positive");
+}
+if (amount % 100 != 0) {
+throw new InvalidAmountException("Amount must be in multiples of ₹100. Please enter valid notes.");
+}
+currentAccount.deposit(amount);
+System.out.println("\n╔═══════════════════════════════════════╗");
+System.out.println("║         DEPOSIT SUCCESSFUL            ║");
+System.out.println("╠═══════════════════════════════════════╣");
+System.out.printf("║  Amount Deposited: ₹%-18.2f║%n", amount);
+System.out.printf("║  New Balance: ₹%-23.2f║%n", currentAccount.getBalance());
+System.out.println("╚═══════════════════════════════════════╝");
+}
+public void ejectCard() {
+System.out.println("\n╔═══════════════════════════════════════╗");
+System.out.println("║   Thank you for using ABC Bank ATM    ║");
+System.out.println("║     Please collect your card.         ║");
+System.out.println("╚═══════════════════════════════════════╝");
+currentAccount = null;
+}
+}
+Experiment 9: Multithreading using Thread Class and Runnable Interface
+public class Experiment9 {
+    public static void main(String[] args) {
+        System.out.println("===== MULTITHREADING IN JAVA =====");
+        NumberPrinter n = new NumberPrinter();
+        Thread l = new Thread(new LetterPrinter());
+        n.start();
+        l.start();
+        try {
+            n.join();
+            l.join();
+        } catch (InterruptedException e) {}
+        Thread t = Thread.currentThread();
+        System.out.println("Thread Name: " + t.getName());
+        System.out.println("Thread ID: " + t.getId());
+        System.out.println("Priority: " + t.getPriority());
+        System.out.println("State: " + t.getState());
+        Counter c = new Counter();
+        Thread c1 = new CounterThread(c);
+        Thread c2 = new CounterThread(c);
+        Thread c3 = new CounterThread(c);
+        c1.start();
+        c2.start();
+        c3.start();
+        try {
+            c1.join();
+            c2.join();
+            c3.join();
+        } catch (InterruptedException e) {}
+        System.out.println("Count: " + c.getCount());
+        PriorityThread low = new PriorityThread("Low");
+        PriorityThread normal = new PriorityThread("Normal");
+        PriorityThread high = new PriorityThread("High");
+        low.setPriority(1);
+        normal.setPriority(5);
+        high.setPriority(10);
+        low.start();
+        normal.start();
+        high.start();
+        SharedBuffer b = new SharedBuffer();
+        new Producer(b).start();
+        new Consumer(b).start();
+        LambdaThreadDemo.runDemo();
+        Thread sleepy = new Thread(() -> {
+            try {
+                System.out.println("Thread sleeping...");
+                Thread.sleep(3000);
+                System.out.println("Thread woke up");
+            } catch (InterruptedException e) {
+                System.out.println("Thread interrupted");
+            }
+        });
+        sleepy.start();
+        try {
+            Thread.sleep(1000);
+            sleepy.interrupt();
+            sleepy.join();
+        } catch (InterruptedException e) {}
+        Thread daemon = new Thread(() -> {
+            while (true) {
+                System.out.println("Daemon running...");
+                try {
+                    Thread.sleep(500);
+                } catch (InterruptedException e) {
+                    break;
+                }
+            }
+        });
+        daemon.setDaemon(true);
+        daemon.start();
+        try {
+            Thread.sleep(1500);
+        } catch (InterruptedException e) {}
+        System.out.println("===== PROGRAM COMPLETED =====");
+    }
+}
+class NumberPrinter extends Thread {
+    public void run() {
+        for (int i = 1; i <= 5; i++) {
+            System.out.println("Number: " + i);
+            try {
+                Thread.sleep(300);
+            } catch (InterruptedException e) {}
+        }
+    }
+}
+class LetterPrinter implements Runnable {
+    public void run() {
+        for (char c = 'A'; c <= 'E'; c++) {
+            System.out.println("Letter: " + c);
+            try {
+                Thread.sleep(300);
+            } catch (InterruptedException e) {}
+        }
+    }
+}
+class Counter {
+    private int count;
+    public synchronized void increment() {
+        count++;
+    }
+    public int getCount() {
+        return count;
+    }
+}
+class CounterThread extends Thread {
+    Counter c;
+    CounterThread(Counter c) {
+        this.c = c;
+    }
+    public void run() {
+        for (int i = 0; i < 1000; i++)
+            c.increment();
+    }
+}
+class PriorityThread extends Thread {
+    PriorityThread(String name) {
+        super(name);
+    }
+    public void run() {
+        System.out.println(getName() + " Priority: " + getPriority());
+    }
+}
+class SharedBuffer {
+    private int data;
+    private boolean available;
+    synchronized void produce(int x) throws InterruptedException {
+        while (available)
+            wait();
+        data = x;
+        available = true;
+        System.out.println("Produced: " + x);
+        notify();
+    }
+    synchronized int consume() throws InterruptedException {
+        while (!available)
+            wait();
+        available = false;
+        System.out.println("Consumed: " + data);
+        notify();
+        return data;
+    }
+}
+class Producer extends Thread {
+    SharedBuffer b;
+    Producer(SharedBuffer b) {
+        this.b = b;
+    }
+    public void run() {
+        try {
+            for (int i = 1; i <= 5; i++) {
+                b.produce(i);
+                Thread.sleep(300);
+            }
+        } catch (InterruptedException e) {}
+    }
+}
+class Consumer extends Thread {
+    SharedBuffer b;
+    Consumer(SharedBuffer b) {
+        this.b = b;
+    }
+    public void run() {
+        try {
+            for (int i = 1; i <= 5; i++) {
+                b.consume();
+                Thread.sleep(500);
+            }
+        } catch (InterruptedException e) {}
+    }
+}
+class LambdaThreadDemo {
+    static void runDemo() {
+        Thread t1 = new Thread(() -> System.out.println("Lambda Thread 1"));
+        Thread t2 = new Thread(() -> System.out.println("Lambda Thread 2"));
+        t1.start();
+        t2.start();
+    }
+}
+Experiment 10: File Handling using File Stream Classes 
+import java.io.*;
+public class Experiment10 {
+    public static void main(String[] args) {
+        String dir="./";
+        String byteFile=dir+"bytes.txt";
+        String charFile=dir+"chars.txt";
+        String bufferFile=dir+"buffer.txt";
+        String printFile=dir+"print.txt";
+        System.out.println("===== FILE HANDLING IN JAVA =====");
+        try {
+            FileOutputStream fos=new FileOutputStream(byteFile);
+            fos.write("Hello Java File Handling\n".getBytes());
+            fos.close();
+            FileInputStream fis=new FileInputStream(byteFile);
+            int b;
+            while((b=fis.read())!=-1)
+                System.out.print((char)b);
+            fis.close();
+            FileWriter fw=new FileWriter(charFile);
+            fw.write("Java FileWriter Example\nCharacter Stream");
+            fw.close();
+            FileReader fr=new FileReader(charFile);
+            int c;
+            while((c=fr.read())!=-1)
+                System.out.print((char)c);
+            fr.close();
+            BufferedWriter bw=new BufferedWriter(new FileWriter(bufferFile));
+            bw.write("BufferedWriter Example");
+            bw.newLine();
+            bw.write("Efficient file writing");
+            bw.close();
+            BufferedReader br=new BufferedReader(new FileReader(bufferFile));
+            String line;
+            while((line=br.readLine())!=null)
+                System.out.println(line);
+            br.close();
+            PrintWriter pw=new PrintWriter(new FileWriter(printFile));
+            pw.println("PrintWriter Example");
+            pw.printf("Integer: %d%n",42);
+            pw.printf("Float: %.2f%n",3.14);
+            pw.close();
+            File file=new File(dir+"test.txt");
+            file.createNewFile();
+            System.out.println("File: "+file.getName());
+            System.out.println("Exists: "+file.exists());
+            System.out.println("Is File: "+file.isFile());
+            System.out.println("Size: "+file.length()+" bytes");
+            File folder=new File(dir+"test_directory");
+            folder.mkdir();
+            for(int i=1;i<=3;i++)
+                new File(folder,"file"+i+".txt").createNewFile();
+            System.out.println("Directory: "+folder.getName());
+            for(File f:folder.listFiles())
+                System.out.println(f.getName());
+            BufferedReader r=new BufferedReader(new FileReader(charFile));
+            BufferedWriter w=new BufferedWriter(new FileWriter(dir+"copy.txt"));
+            while((line=r.readLine())!=null){
+                w.write(line);
+                w.newLine();
+            }
+            r.close();
+            w.close();
+            System.out.println("File copied successfully");
+            FileWriter aw=new FileWriter(dir+"append.txt");
+            aw.write("Initial content\n");
+            aw.close();
+            aw=new FileWriter(dir+"append.txt",true);
+            aw.write("Appended content\n");
+            aw.close();
+            System.out.println("Content appended successfully");
+            System.out.println("===== FILE HANDLING COMPLETED =====");
+        } catch(IOException e) {
+            System.out.println("Error: "+e.getMessage());
+        }
+    }
+}
+ 
+Experiment 11: ArrayList Insertion and Deletion Operations 
+import java.util.*;
+public class Experiment11 {
+    static void display(ArrayList<?> list) {
+        System.out.println("Content: " + list);
+        System.out.println("Size: " + list.size());
+    }
+    public static void main(String[] args) {
+        ArrayList<String> fruits = new ArrayList<>();
+        System.out.println("===== ArrayList OPERATIONS =====");
+        fruits.add("Apple");
+        fruits.add("Banana");
+        fruits.add("Cherry");
+        fruits.add(1, "Mango");
+        fruits.add(0, "Grapes");
+        fruits.addAll(Arrays.asList("Orange", "Kiwi", "Papaya"));
+        fruits.addAll(3, Arrays.asList("Strawberry", "Blueberry"));
+        fruits.set(0, "Green Grapes");
+        System.out.println("\nInsertion:");
+        display(fruits);
+        fruits.remove(0);
+        fruits.remove("Kiwi");
+        fruits.removeAll(Arrays.asList("Strawberry", "Blueberry"));
+        fruits.addAll(Arrays.asList("Apricot", "Avocado", "Plum"));
+        fruits.removeIf(f -> f.startsWith("A"));
+        Iterator<String> it = fruits.iterator();
+        while (it.hasNext())
+            if (it.next().startsWith("P"))
+                it.remove();
+        fruits.addAll(Arrays.asList("Apple", "Banana", "Cherry", "Date"));
+        fruits.retainAll(Arrays.asList("Apple", "Banana", "Cherry"));
+        System.out.println("\nDeletion:");
+        display(fruits);
+        fruits.clear();
+        System.out.println("After clear: " + fruits);
+        System.out.println("isEmpty: " + fruits.isEmpty());
+        fruits = new ArrayList<>(Arrays.asList("Apple", "Banana", "Cherry", "Date", "Apple", "Elderberry", "Apple"));
+        System.out.println("\nSearch:");
+        System.out.println("contains Banana: " + fruits.contains("Banana"));
+        System.out.println("indexOf Apple: " + fruits.indexOf("Apple"));
+        System.out.println("lastIndexOf Apple: " + fruits.lastIndexOf("Apple"));
+        System.out.println("get(2): " + fruits.get(2));
+        System.out.println("\ntoArray: " + Arrays.toString(fruits.toArray()));
+        System.out.println("subList(1,4): " + fruits.subList(1, 4));
+        Collections.sort(fruits);
+        System.out.println("Sorted: " + fruits);
+        Collections.sort(fruits, Collections.reverseOrder());
+        System.out.println("Reverse Sorted: " + fruits);
+        System.out.print("\nFor-each: ");
+        for (String f : fruits)
+            System.out.print(f + " ");
+        System.out.print("\nLambda: ");
+        fruits.forEach(f -> System.out.print(f + " | "));
+        ListIterator<String> li = fruits.listIterator();
+        System.out.print("\nForward: ");
+        while (li.hasNext())
+            System.out.print(li.next() + " ");
+        System.out.print("\nBackward: ");
+        while (li.hasPrevious())
+            System.out.print(li.previous() + " ");
+        ArrayList<Integer> numbers = new ArrayList<>(Arrays.asList(5, 2, 8, 1, 9, 3, 7));
+        numbers.add(10);
+        numbers.add(0, 0);
+        numbers.remove(Integer.valueOf(5));
+        numbers.remove(0);
+        Collections.sort(numbers);
+        System.out.println("\n\nInteger ArrayList:");
+        display(numbers);
+        System.out.println("Sum: " + numbers.stream().mapToInt(Integer::intValue).sum());
+        System.out.println("Max: " + Collections.max(numbers));
+        System.out.println("Min: " + Collections.min(numbers));
+        System.out.println("\n===== PROGRAM COMPLETED =====");
+    }
+}
+Experiment 12: LinkedList Traversal using ListIterator
+import java.util.*;
+public class Experiment12 {
+    static void display(LinkedList<?> list) {
+        System.out.println("Content: " + list);
+        System.out.println("Size: " + list.size());
+    }
+    public static void main(String[] args) {
+        LinkedList<String> countries = new LinkedList<>();
+        countries.addAll(Arrays.asList("India","USA","UK","Canada","Australia","Germany","France"));
+        System.out.println("===== LinkedList TRAVERSAL =====");
+        display(countries);
+        ListIterator<String> it = countries.listIterator();
+        System.out.print("\nForward: ");
+        while (it.hasNext())
+            System.out.print(it.next() + " ");
+        System.out.print("\nBackward: ");
+        while (it.hasPrevious())
+            System.out.print(it.previous() + " ");
+        ListIterator<String> mid = countries.listIterator(3);
+        System.out.print("\n\nFrom index 3: ");
+        while (mid.hasNext())
+            System.out.print(mid.next() + " ");
+        while (mid.hasPrevious())
+            mid.previous();
+        ListIterator<String> modify = countries.listIterator();
+        while (modify.hasNext()) {
+            String s = modify.next();
+            if (s.equals("USA"))
+                modify.set("United States");
+            if (s.equals("UK"))
+                modify.set("United Kingdom");
+        }
+        System.out.println("\n\nAfter set():");
+        display(countries);
+        ListIterator<String> add = countries.listIterator();
+        while (add.hasNext()) {
+            if (add.next().equals("Canada"))
+                add.add("Japan");
+        }
+        add = countries.listIterator();
+        add.add("Brazil");
+        System.out.println("\nAfter add():");
+        display(countries);
+        ListIterator<String> remove = countries.listIterator();
+        while (remove.hasNext()) {
+            String s = remove.next();
+            if (s.equals("Japan") || s.equals("Brazil"))
+                remove.remove();
+        }
+        System.out.println("\nAfter remove():");
+        display(countries);
+        ListIterator<String> index = countries.listIterator(3);
+        System.out.println("\nnextIndex(): " + index.nextIndex());
+        System.out.println("previousIndex(): " + index.previousIndex());
+        Iterator<String> simple = countries.iterator();
+        System.out.print("\nIterator: ");
+        while (simple.hasNext())
+            System.out.print(simple.next() + " ");
+        LinkedList<Integer> numbers = new LinkedList<>();
+        for (int i=1;i<=5;i++)
+            numbers.add(i*10);
+        System.out.println("\n\n===== LinkedList as Deque =====");
+        display(numbers);
+        System.out.println("getFirst(): " + numbers.getFirst());
+        System.out.println("getLast(): " + numbers.getLast());
+        numbers.addFirst(5);
+        numbers.addLast(60);
+        System.out.println("After addFirst/addLast: " + numbers);
+        System.out.println("pollFirst(): " + numbers.pollFirst());
+        System.out.println("pollLast(): " + numbers.pollLast());
+        numbers.push(0);
+        System.out.println("pop(): " + numbers.pop());
+        LinkedList<String> letters = new LinkedList<>(Arrays.asList("A","B","C","D","E"));
+        ListIterator<String> li = letters.listIterator();
+        System.out.print("\nZigzag Forward: ");
+        while (li.hasNext())
+            System.out.print(li.next() + " ");
+        System.out.print("\nZigzag Backward: ");
+        while (li.hasPrevious())
+            System.out.print(li.previous() + " ");
+        System.out.println("\n\n===== PROGRAM COMPLETED =====");
+    }
+}
+Experiment 13: GUI Application using Swing Package 
+import javax.swing.*;
+import javax.swing.border.*;
+import java.awt.*;
+public class Experiment9 extends JFrame {
+    JTextField name,email,phone;
+    JPasswordField password;
+    JRadioButton male,female,other;
+    JCheckBox java,python,cpp,js;
+    JComboBox<String> course;
+    JTextArea address,output;
+    JSpinner age;
+    JSlider experience;
+    JButton submit,clear,exit;
+    public Experiment13() {
+        setTitle("Student Registration Form");
+        setSize(800,700);
+        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        setLocationRelativeTo(null);
+        JPanel main=new JPanel(new BorderLayout(10,10));
+        main.setBorder(new EmptyBorder(15,15,15,15));
+        JLabel title=new JLabel("Student Registration Form",JLabel.CENTER);
+        title.setFont(new Font("Arial",Font.BOLD,24));
+        main.add(title,BorderLayout.NORTH);
+        JPanel form=new JPanel(new GridBagLayout());
+        form.setBorder(new TitledBorder("Personal Information"));
+        GridBagConstraints g=new GridBagConstraints();
+        g.insets=new Insets(5,5,5,5);
+        g.fill=GridBagConstraints.HORIZONTAL;
+        name=new JTextField(20);
+        email=new JTextField(20);
+        password=new JPasswordField(20);
+        phone=new JTextField(20);
+        age=new JSpinner(new SpinnerNumberModel(18,15,60,1));
+        add(form,g,0,"Full Name:",name);
+        add(form,g,1,"Email:",email);
+        add(form,g,2,"Password:",password);
+        add(form,g,3,"Phone:",phone);
+        add(form,g,4,"Age:",age);
+        male=new JRadioButton("Male");
+        female=new JRadioButton("Female");
+        other=new JRadioButton("Other");
+        ButtonGroup bg=new ButtonGroup();
+        bg.add(male); bg.add(female); bg.add(other);
+        JPanel gender=new JPanel();
+        gender.add(male); gender.add(female); gender.add(other);
+        add(form,g,5,"Gender:",gender);
+        course=new JComboBox<>(new String[]{"Select Course","Computer Science","IT","Electronics","Mechanical","Civil"});
+        add(form,g,6,"Course:",course);
+        java=new JCheckBox("Java");
+        python=new JCheckBox("Python");
+        cpp=new JCheckBox("C++");
+        js=new JCheckBox("JavaScript");
+        JPanel skills=new JPanel();
+        skills.add(java); skills.add(python); skills.add(cpp); skills.add(js);
+        add(form,g,7,"Skills:",skills);
+        experience=new JSlider(0,10,0);
+        experience.setPaintTicks(true);
+        experience.setPaintLabels(true);
+        experience.setMajorTickSpacing(2);
+        add(form,g,8,"Experience:",experience);
+        address=new JTextArea(3,20);
+        add(form,g,9,"Address:",new JScrollPane(address));
+        main.add(form,BorderLayout.CENTER);
+        submit=new JButton("Submit");
+        clear=new JButton("Clear");
+        exit=new JButton("Exit");
+        JPanel buttons=new JPanel();
+        buttons.add(submit); buttons.add(clear); buttons.add(exit);
+        output=new JTextArea(7,40);
+        output.setEditable(false);
+        JPanel out=new JPanel(new BorderLayout());
+        out.setBorder(new TitledBorder("Output"));
+        out.add(new JScrollPane(output));
+        JPanel south=new JPanel(new BorderLayout());
+        south.add(buttons,BorderLayout.NORTH);
+        south.add(out,BorderLayout.CENTER);
+        main.add(south,BorderLayout.SOUTH);
+        add(main);
+        submit.addActionListener(e->submitForm());
+        clear.addActionListener(e->clearForm());
+        exit.addActionListener(e->System.exit(0));
+    }
+    void add(JPanel p,GridBagConstraints g,int row,String label,Component c) {
+        g.gridx=0; g.gridy=row; g.gridwidth=1;
+        p.add(new JLabel(label),g);
+        g.gridx=1; g.gridwidth=2;
+        p.add(c,g);
+    }
+    void submitForm() {
+        if(name.getText().trim().isEmpty()||email.getText().trim().isEmpty()||course.getSelectedIndex()==0) {
+            JOptionPane.showMessageDialog(this,"Enter Name, Email and Course");
+            return;
+        }
+        String gender=male.isSelected()?"Male":female.isSelected()?"Female":other.isSelected()?"Other":"None";
+        String skills="";
+        if(java.isSelected()) skills+="Java ";
+        if(python.isSelected()) skills+="Python ";
+        if(cpp.isSelected()) skills+="C++ ";
+        if(js.isSelected()) skills+="JavaScript";
+        output.setText("===== REGISTRATION DETAILS =====\n"+
+            "Name: "+name.getText()+"\n"+
+            "Email: "+email.getText()+"\n"+
+            "Phone: "+phone.getText()+"\n"+
+            "Age: "+age.getValue()+"\n"+
+            "Gender: "+gender+"\n"+
+            "Course: "+course.getSelectedItem()+"\n"+
+            "Skills: "+skills+"\n"+
+            "Experience: "+experience.getValue()+" years\n"+
+            "Address: "+address.getText()+"\n"+
+            "Registration submitted successfully!");
+        JOptionPane.showMessageDialog(this,"Registration submitted successfully!");
+    }
+    void clearForm() {
+        name.setText("");
+        email.setText("");
+        password.setText("");
+        phone.setText("");
+        age.setValue(18);
+        male.setSelected(false);
+        female.setSelected(false);
+        other.setSelected(false);
+        course.setSelectedIndex(0);
+        java.setSelected(false);
+        python.setSelected(false);
+        cpp.setSelected(false);
+        js.setSelected(false);
+        experience.setValue(0);
+        address.setText("");
+        output.setText("");
+    }
+    public static void main(String[] args) {
+        SwingUtilities.invokeLater(()->new Experiment13().setVisible(true));
+    }
+}
+Experiment 14: Event Handling using Anonymous Inner Classes 
+import javax.swing.*;
+import javax.swing.border.*;
+import java.awt.*;
+import java.awt.event.*;
+public class Experiment14 extends JFrame {
+    JTextArea logArea;
+    int count=0;
+    public Experiment14() {
+        setTitle("Event Handling using Anonymous Inner Classes");
+        setSize(800,650);
+        setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
+        setLocationRelativeTo(null);
+        JPanel main=new JPanel(new BorderLayout(10,10));
+        main.setBorder(new EmptyBorder(10,10,10,10));
+        JLabel head=new JLabel("Event Handling Demonstration",JLabel.CENTER);
+        head.setFont(new Font("Arial",Font.BOLD,20));
+        main.add(head,BorderLayout.NORTH);
+        JPanel center=new JPanel(new GridLayout(3,2,10,10));
+        JPanel p1=panel("1. ActionListener");
+        JButton b=new JButton("Click Me");
+        b.addActionListener(new ActionListener(){
+            public void actionPerformed(ActionEvent e){
+                count++;
+                log("ActionEvent: Button clicked - "+count);
+            }
+        });
+        p1.add(b);
+        center.add(p1);
+        JPanel p2=panel("2. MouseListener");
+        JLabel mouse=new JLabel("Click / Hover",JLabel.CENTER);
+        mouse.setPreferredSize(new Dimension(150,70));
+        mouse.addMouseListener(new MouseListener(){
+            public void mouseClicked(MouseEvent e){log("MouseEvent: CLICKED");}
+            public void mousePressed(MouseEvent e){log("MouseEvent: PRESSED");}
+            public void mouseReleased(MouseEvent e){log("MouseEvent: RELEASED");}
+            public void mouseEntered(MouseEvent e){log("MouseEvent: ENTERED");}
+            public void mouseExited(MouseEvent e){log("MouseEvent: EXITED");}
+        });
+        p2.add(mouse);
+        center.add(p2);
+        JPanel p3=panel("3. KeyListener");
+        JTextField key=new JTextField("Type here",15);
+        key.addKeyListener(new KeyListener(){
+            public void keyTyped(KeyEvent e){log("KeyEvent: TYPED - "+e.getKeyChar());}
+            public void keyPressed(KeyEvent e){log("KeyEvent: PRESSED - "+KeyEvent.getKeyText(e.getKeyCode()));}
+            public void keyReleased(KeyEvent e){log("KeyEvent: RELEASED");}
+        });
+        p3.add(key);
+        center.add(p3);
+        JPanel p4=panel("4. ItemListener");
+        JCheckBox c1=new JCheckBox("Option 1");
+        JCheckBox c2=new JCheckBox("Option 2");
+        JComboBox<String> combo=new JComboBox<>(new String[]{"Select","Java","Python","C++"});
+        ItemListener il=new ItemListener(){
+            public void itemStateChanged(ItemEvent e){
+                if(e.getStateChange()==ItemEvent.SELECTED)
+                    log("ItemEvent: "+e.getItem());
+            }
+        };
+        c1.addItemListener(il);
+        c2.addItemListener(il);
+        combo.addItemListener(il);
+        p4.add(c1); p4.add(c2); p4.add(combo);
+        center.add(p4);
+        JPanel p5=panel("5. FocusListener");
+        JTextField f1=new JTextField("Field 1",10);
+        JTextField f2=new JTextField("Field 2",10);
+        FocusListener fl=new FocusListener(){
+            public void focusGained(FocusEvent e){log("FocusEvent: GAINED");}
+            public void focusLost(FocusEvent e){log("FocusEvent: LOST");}
+        };
+        f1.addFocusListener(fl);
+        f2.addFocusListener(fl);
+        p5.add(f1); p5.add(f2);
+        center.add(p5);
+        JPanel p6=panel("6. MouseMotionListener");
+        JLabel motion=new JLabel("Move mouse here",JLabel.CENTER);
+        motion.setPreferredSize(new Dimension(150,70));
+        motion.addMouseMotionListener(new MouseMotionListener(){
+            public void mouseMoved(MouseEvent e){motion.setText("Position: "+e.getX()+","+e.getY());}
+            public void mouseDragged(MouseEvent e){motion.setText("Dragging: "+e.getX()+","+e.getY());}
+        });
+        p6.add(motion);
+        center.add(p6);
+        main.add(center,BorderLayout.CENTER);
+        logArea=new JTextArea(8,50);
+        logArea.setEditable(false);
+        JButton clear=new JButton("Clear Log");
+        clear.addActionListener(new ActionListener(){
+            public void actionPerformed(ActionEvent e){
+                logArea.setText("");
+                count=0;
+            }
+        });
+        JPanel log=new JPanel(new BorderLayout());
+        log.setBorder(new TitledBorder("Event Log"));
+        log.add(new JScrollPane(logArea),BorderLayout.CENTER);
+        log.add(clear,BorderLayout.SOUTH);
+        main.add(log,BorderLayout.SOUTH);
+        add(main);
+        addWindowListener(new WindowListener(){
+            public void windowOpened(WindowEvent e){log("WindowEvent: OPENED");}
+            public void windowClosing(WindowEvent e){
+                int x=JOptionPane.showConfirmDialog(Experiment14.this,"Exit?","Confirm",JOptionPane.YES_NO_OPTION);
+                if(x==JOptionPane.YES_OPTION) System.exit(0);
+            }
+            public void windowClosed(WindowEvent e){log("WindowEvent: CLOSED");}
+            public void windowIconified(WindowEvent e){log("WindowEvent: ICONIFIED");}
+            public void windowDeiconified(WindowEvent e){log("WindowEvent: DEICONIFIED");}
+            public void windowActivated(WindowEvent e){log("WindowEvent: ACTIVATED");}
+            public void windowDeactivated(WindowEvent e){log("WindowEvent: DEACTIVATED");}
+        });
+        log("Application started.");
+    }
+    JPanel panel(String title){
+        JPanel p=new JPanel(new FlowLayout());
+        p.setBorder(new TitledBorder(title));
+        return p;
+    }
+    void log(String s){
+        if(logArea!=null) logArea.append(s+"\n");
+    }
+    public static void main(String[] args){
+        SwingUtilities.invokeLater(new Runnable(){
+            public void run(){
+                new Experiment14().setVisible(true);
+            }
+        });
+    }
+}
+Experiment 15: Database Connectivity using JDBC for CRUD Operations
+import java.sql.*;
+import java.util.Scanner;
+public class ex15{
+    static final String URL="jdbc:mysql://sql.freedb.tech/freedb_bsVOiTyJ";
+    static final String USER="u_2c76qE";
+    static final String PASSWORD="UKxEJVaF0FY8";
+    public static void main(String[] args){
+        Scanner sc=new Scanner(System.in);
+        try{
+            Connection con=DriverManager.getConnection(URL,USER,PASSWORD);
+            System.out.println("================================");
+            System.out.println("   JDBC DATABASE CONNECTED");
+            System.out.println("================================");
+            int choice;
+            do{
+                System.out.println("\n===== STUDENT DATABASE =====");
+                System.out.println("1. Insert Student");
+                System.out.println("2. Display Students");
+                System.out.println("3. Update Student");
+                System.out.println("4. Delete Student");
+                System.out.println("5. Exit");
+                System.out.print("Enter your choice: ");
+                choice=sc.nextInt();
+                switch(choice){
+                    case 1:
+                        System.out.print("Enter Student ID: ");
+                        int id=sc.nextInt();
+                        sc.nextLine();
+                        System.out.print("Enter Student Name: ");
+                        String name=sc.nextLine();
+                        System.out.print("Enter Marks: ");
+                        int marks=sc.nextInt();
+                        String insertQuery="INSERT INTO student VALUES (?, ?, ?)";
+                        PreparedStatement insertStmt=con.prepareStatement(insertQuery);
+                        insertStmt.setInt(1,id);
+                        insertStmt.setString(2,name);
+                        insertStmt.setInt(3,marks);
+                        int inserted=insertStmt.executeUpdate();
+                        if(inserted>0) System.out.println("Student inserted successfully!");
+                        insertStmt.close();
+                        break;
+                    case 2:
+                        String selectQuery="SELECT * FROM student";
+                        Statement stmt=con.createStatement();
+                        ResultSet rs=stmt.executeQuery(selectQuery);
+                        System.out.println("\n--------------------------------");
+                        System.out.println("ID\tName\tMarks");
+                        System.out.println("--------------------------------");
+                        while(rs.next()){
+                            int sid=rs.getInt("id");
+                            String sname=rs.getString("name");
+                            int smarks=rs.getInt("marks");
+                            System.out.println(sid+"\t"+sname+"\t"+smarks);
+                        }
+                        rs.close();
+                        stmt.close();
+                        break;
+                    case 3:
+                        System.out.print("Enter Student ID to update: ");
+                        int updateId=sc.nextInt();
+                        System.out.print("Enter new marks: ");
+                        int newMarks=sc.nextInt();
+                        String updateQuery="UPDATE student SET marks = ? WHERE id = ?";
+                        PreparedStatement updateStmt=con.prepareStatement(updateQuery);
+                        updateStmt.setInt(1,newMarks);
+                        updateStmt.setInt(2,updateId);
+                        int updated=updateStmt.executeUpdate();
+                        if(updated>0) System.out.println("Student updated successfully!");
+                        else System.out.println("Student ID not found.");
+                        updateStmt.close();
+                        break;
+                    case 4:
+                        System.out.print("Enter Student ID to delete: ");
+                        int deleteId=sc.nextInt();
+                        String deleteQuery="DELETE FROM student WHERE id = ?";
+                        PreparedStatement deleteStmt=con.prepareStatement(deleteQuery);
+                        deleteStmt.setInt(1,deleteId);
+                        int deleted=deleteStmt.executeUpdate();
+                        if(deleted>0) System.out.println("Student deleted successfully!");
+                        else System.out.println("Student ID not found.");
+                        deleteStmt.close();
+                        break;
+                    case 5:
+                        System.out.println("Exiting program...");
+                        break;
+                    default:
+                        System.out.println("Invalid choice! Try again.");
+                }
+            }while(choice!=5);
+            con.close();
+            System.out.println("Database connection closed.");
+        }catch(SQLException e){
+            System.out.println("Database Error: "+e.getMessage());
+        }
+        sc.close();
+    }
+}
+CREATE DATABASE studentdb;
+USE studentdb;
+CREATE TABLE student(
+    id INT PRIMARY KEY,
+    name VARCHAR(50),
+    marks INT
+);
+INSERT INTO student VALUES
+(101,'Sanjay',85),
+(102,'Arun',90),
+(103,'Kumar',78);
+SELECT * FROM student;
+
+
+
+
+
+
+""")