Group C — Long / numerical Questions (15 marks)

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

// 1. Custom Exception (Exception Handling)
class InsufficientFundsException extends Exception {
    public InsufficientFundsException(String message) {
        super(message);
    }
}

// 2. Abstract Base Class (Abstraction & Encapsulation)
abstract class Account {
    private String accountNumber; // Encapsulated
    protected double balance;     // Accessible to child classes

    public Account(String accountNumber, double balance) {
        this.accountNumber = accountNumber;
        this.balance = balance;
    }

    public String getAccountNumber() { return accountNumber; }
    public double getBalance() { return balance; }

    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            logTransaction("Deposited: $" + amount + " | New Balance: $" + balance);
        }
    }

    // Polymorphic method to be overridden
    public abstract void withdraw(double amount) throws InsufficientFundsException;

    // 3. File I/O for persistent logging
    protected void logTransaction(String message) {
        try (FileWriter fw = new FileWriter(accountNumber + "_log.txt", true);
             PrintWriter pw = new PrintWriter(fw)) {
            pw.println(message);
        } catch (IOException e) {
            System.err.println("Failed to log transaction for " + accountNumber);
        }
    }
}

// 4. Inheritance & Polymorphism (Savings Account)
class SavingsAccount extends Account {
    private double minimumBalance = 500.0;

    public SavingsAccount(String accNo, double initialBalance) {
        super(accNo, initialBalance);
    }

    @Override
    public void withdraw(double amount) throws InsufficientFundsException {
        if (balance - amount < minimumBalance) {
            throw new InsufficientFundsException("Transaction Failed: Minimum balance of $500 must be maintained.");
        }
        balance -= amount;
        logTransaction("Withdrew: $" + amount + " | New Balance: $" + balance);
    }
}

// 5. Inheritance & Polymorphism (Current Account)
class CurrentAccount extends Account {
    private double overdraftLimit = 1000.0;

    public CurrentAccount(String accNo, double initialBalance) {
        super(accNo, initialBalance);
    }

    @Override
    public void withdraw(double amount) throws InsufficientFundsException {
        if (balance - amount < -overdraftLimit) {
            throw new InsufficientFundsException("Transaction Failed: Overdraft limit of $" + overdraftLimit + " exceeded.");
        }
        balance -= amount;
        logTransaction("Withdrew: $" + amount + " | New Balance: $" + balance);
    }
}

// Execution Class
public class BankingSystem {
    public static void main(String[] args) {
        try {
            Account mySavings = new SavingsAccount("SAV-101", 2000);
            mySavings.deposit(500);
            mySavings.withdraw(300); // Success
            System.out.println("Savings Balance: $" + mySavings.getBalance());
            
            mySavings.withdraw(2000); // Throws Exception
        } catch (InsufficientFundsException e) {
            System.err.println(e.getMessage());
        }
    }
}

// 1. The Strategy Interface (Super type)
interface PaymentStrategy {
    void processPayment(double amount);
}

// 2. Concrete Implementation A (Sub type)
class CreditCardPayment implements PaymentStrategy {
    private String cardNumber;
    public CreditCardPayment(String card) { this.cardNumber = card; }
    
    @Override
    public void processPayment(double amount) {
        System.out.println("Processing $" + amount + " via Credit Card: " + cardNumber);
        // Complex credit card API logic here
    }
}

// 3. Concrete Implementation B (Sub type)
class UPIPayment implements PaymentStrategy {
    private String upiId;
    public UPIPayment(String upi) { this.upiId = upi; }
    
    @Override
    public void processPayment(double amount) {
        System.out.println("Processing $" + amount + " via UPI: " + upiId);
        // Complex UPI API logic here
    }
}

// 4. The Core Application
class ShoppingCart {
    // Pluggable dependency - Notice we use the interface reference!
    private PaymentStrategy paymentMethod;

    // Injecting the strategy at runtime
    public void setPaymentMethod(PaymentStrategy strategy) {
        this.paymentMethod = strategy;
    }

    public void checkout(double totalAmount) {
        if (paymentMethod == null) throw new IllegalStateException("Select a payment method.");
        
        // Dynamic Method Dispatch happens here!
        // The compiler only knows paymentMethod is of type PaymentStrategy.
        // The JVM dynamically calls the CreditCard or UPI processPayment at runtime.
        paymentMethod.processPayment(totalAmount);
    }
}

// Execution
public class Main {
    public static void main(String[] args) {
        ShoppingCart cart = new ShoppingCart();
        
        // User selects UPI at runtime
        cart.setPaymentMethod(new UPIPayment("user@okhdfcbank"));
        cart.checkout(150.50); // Outputs: Processing $150.5 via UPI
        
        // User switches to Credit Card at runtime
        cart.setPaymentMethod(new CreditCardPayment("4111-2222-3333-4444"));
        cart.checkout(5000.00); // Outputs: Processing $5000.0 via Credit Card
    }
}

import java.util.LinkedList;

// The Shared Buffer Class
class SharedBuffer {
    private LinkedList<Integer> list = new LinkedList<>();
    private int capacity = 2; // Bounded buffer size

    // Called by Producer thread
    public void produce() throws InterruptedException {
        int value = 0;
        while (true) {
            synchronized (this) {
                // Wait if buffer is full
                while (list.size() == capacity) {
                    System.out.println("Buffer is full. Producer is waiting...");
                    wait(); // Releases lock and waits
                }

                System.out.println("Producer produced: " + value);
                list.add(value++); // Add data to buffer

                // Notify the consumer that data is available
                notify();

                // Sleep to simulate time taken to produce
                Thread.sleep(1000);
            }
        }
    }

    // Called by Consumer thread
    public void consume() throws InterruptedException {
        while (true) {
            synchronized (this) {
                // Wait if buffer is empty
                while (list.size() == 0) {
                    System.out.println("Buffer is empty. Consumer is waiting...");
                    wait(); // Releases lock and waits
                }

                // Consume data
                int val = list.removeFirst();
                System.out.println("Consumer consumed: " + val);

                // Notify the producer that space is available
                notify();

                // Sleep to simulate time taken to consume
                Thread.sleep(1000);
            }
        }
    }
}

// Main Execution Class
public class ProducerConsumerDemo {
    public static void main(String[] args) throws InterruptedException {
        final SharedBuffer buffer = new SharedBuffer();

        // Create Producer Thread
        Thread producerThread = new Thread(new Runnable() {
            @Override
            public void run() {
                try { buffer.produce(); }
                catch (InterruptedException e) { e.printStackTrace(); }
            }
        });

        // Create Consumer Thread
        Thread consumerThread = new Thread(new Runnable() {
            @Override
            public void run() {
                try { buffer.consume(); }
                catch (InterruptedException e) { e.printStackTrace(); }
            }
        });

        // Start both threads
        producerThread.start();
        consumerThread.start();
    }
}

import java.util.Scanner;

// 1. Creating a Custom Checked Exception
class InvalidAgeException extends Exception {
    public InvalidAgeException(String message) {
        super(message);
    }
}

public class RobustExceptionHandling {
    
    // Method declaring it might throw a custom checked exception
    public static void validateVoterEligibility(int age) throws InvalidAgeException {
        if (age < 18) {
            throw new InvalidAgeException("Applicant is under 18. Voting strictly prohibited.");
        }
        System.out.println("Age verified. Applicant is eligible to vote.");
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Outer Try-Catch
        try {
            System.out.print("Enter total registered voters (for calculation): ");
            String inputVoters = scanner.nextLine();
            
            // Multiple Catch scenario - parsing integer
            int totalVoters = Integer.parseInt(inputVoters);
            
            System.out.print("Enter polling booths available: ");
            int booths = scanner.nextInt();
            
            // Nested Try-Catch for specific logic isolation
            try {
                int votersPerBooth = totalVoters / booths;
                System.out.println("Voters per booth: " + votersPerBooth);
            } catch (ArithmeticException ae) {
                System.err.println("Inner Catch: Cannot divide by zero booths! " + ae.getMessage());
            }

            System.out.print("Enter voter age for registration: ");
            int age = scanner.nextInt();
            
            // Calling a method that throws a checked exception
            validateVoterEligibility(age);
            
        } 
        // Handling Multiple Exceptions (Ordering matters: Most specific to least specific)
        catch (NumberFormatException nfe) {
            System.err.println("Outer Catch: Invalid number format. Please enter valid integers.");
        } 
        catch (InvalidAgeException iae) {
            System.err.println("Outer Catch: Validation Error -> " + iae.getMessage());
        } 
        catch (Exception e) {
            // Generic fallback for any unforeseen exceptions
            System.err.println("Outer Catch: An unexpected error occurred -> " + e.toString());
        } 
        finally {
            // Cleanup block always executes
            System.out.println("Finally Block: Releasing scanner resources and closing connection.");
            scanner.close();
        }
        
        System.out.println("Program execution completed smoothly.");
    }
}