PersonalFinanceManager.java

import java.io.*;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.ArrayList;

// ==================== UNIT 1: OOP FUNDAMENTALS & JAVA BASICS ====================

/**
 * Abstract class demonstrating Abstraction
 * Represents a bank account with basic operations
 */
abstract class Account {
    private String accountId;
    private String accountHolder;
    protected double balance;
    private static int accountCounter = 0; // Static member
    
    /**
     * Constructor for Account
     * @param accountHolder Name of the account holder
     * @param initialBalance Initial balance amount
     */
    public Account(String accountHolder, double initialBalance) {
        this.accountId = "ACC" + (++accountCounter);
        this.accountHolder = accountHolder;
        this.balance = initialBalance;
    }
    
    // Encapsulation - Getters and Setters
    public String getAccountId() { 
        return accountId; 
    }
    
    public String getAccountHolder() { 
        return accountHolder; 
    }
    
    public double getBalance() { 
        return balance; 
    }
    
    // Abstract method - must be implemented by subclasses
    public abstract void displayAccountType();
    
    // Method with access specifier
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println("Deposited: $" + amount);
        }
    }
    
    public void withdraw(double amount) throws InsufficientFundsException {
        if (amount > balance) {
            throw new InsufficientFundsException("Insufficient funds! Balance: $" + balance);
        }
        balance -= amount;
        System.out.println("Withdrawn: $" + amount);
    }
    
    // Static method
    public static int getTotalAccounts() {
        return accountCounter;
    }
}

// ==================== UNIT 2: INHERITANCE & INTERFACES ====================

// Subclass demonstrating Inheritance
class SavingsAccount extends Account {
    private double interestRate;
    
    public SavingsAccount(String accountHolder, double initialBalance, double interestRate) {
        super(accountHolder, initialBalance); // Call to super class constructor
        this.interestRate = interestRate;
    }
    
    @Override
    public void displayAccountType() {
        System.out.println("Account Type: Savings Account");
    }
    
    public void applyInterest() {
        double interest = balance * interestRate / 100;
        balance += interest;
        System.out.println("Interest applied: $" + interest);
    }
}

// Another subclass
class CurrentAccount extends Account {
    private double overdraftLimit;
    
    public CurrentAccount(String accountHolder, double initialBalance, double overdraftLimit) {
        super(accountHolder, initialBalance);
        this.overdraftLimit = overdraftLimit;
    }
    
    @Override
    public void displayAccountType() {
        System.out.println("Account Type: Current Account");
    }
    
    @Override
    public void withdraw(double amount) throws InsufficientFundsException {
        if (amount > balance + overdraftLimit) {
            throw new InsufficientFundsException("Exceeds overdraft limit!");
        }
        balance -= amount;
        System.out.println("Withdrawn: $" + amount);
    }
}

// Interface definition
interface Transactionable {
    void recordTransaction(Transaction transaction);
    void displayTransactionHistory();
}

// Interface implementation
class TransactionManager implements Transactionable {
    private ArrayList<Transaction> transactions;
    
    public TransactionManager() {
        transactions = new ArrayList<>();
    }
    
    @Override
    public void recordTransaction(Transaction transaction) {
        transactions.add(transaction);
    }
    
    @Override
    public void displayTransactionHistory() {
        System.out.println("\n=== Transaction History ===");
        for (Transaction t : transactions) {
            System.out.println(t);
        }
    }
    
    public ArrayList<Transaction> getTransactions() {
        return transactions;
    }
}

// Class using String operations
class Transaction {
    private String type;
    private double amount;
    private String date;
    private String description;
    
    public Transaction(String type, double amount, String description) {
        this.type = type;
        this.amount = amount;
        this.description = description;
        this.date = LocalDate.now().toString();
    }
    
    @Override
    public String toString() {
        return String.format("%s | %s | $%.2f | %s", date, type, amount, description);
    }
    
    public String getType() { 
        return type; 
    }
    
    public double getAmount() { 
        return amount; 
    }
}

// Inner class demonstration
class Budget {
    private String category;
    private double limit;
    private double spent;
    
    public Budget(String category, double limit) {
        this.category = category;
        this.limit = limit;
        this.spent = 0;
    }
    
    public void addExpense(double amount) {
        spent += amount;
    }
    
    public boolean isOverBudget() {
        return spent > limit;
    }
    
    // Inner class
    class BudgetAlert {
        public void checkAndAlert() {
            if (spent > limit * 0.9) {
                System.out.println("WARNING: " + category + " budget at " + 
                                 String.format("%.1f%%", (spent/limit)*100));
            }
        }
    }
    
    public void displayBudget() {
        System.out.printf("%s: $%.2f / $%.2f (%.1f%%)%n", 
                         category, spent, limit, (spent/limit)*100);
        BudgetAlert alert = new BudgetAlert();
        alert.checkAndAlert();
    }
    
    public String getCategory() { 
        return category; 
    }
}

// ==================== UNIT 3: EXCEPTION HANDLING & I/O ====================

// Custom exception
class InsufficientFundsException extends Exception {
    public InsufficientFundsException(String message) {
        super(message);
    }
}

// File I/O operations
class FileManager {
    private static final String FILENAME = "financial_data.txt";
    
    // Writing to file
    public static void saveData(ArrayList<Transaction> transactions) {
        BufferedWriter writer = null;
        try {
            writer = new BufferedWriter(new FileWriter(FILENAME));
            writer.write("=== Financial Data Report ===\n");
            writer.write("Generated on: " + LocalDateTime.now() + "\n\n");
            
            for (Transaction t : transactions) {
                writer.write(t.toString() + "\n");
            }
            
            System.out.println("Data saved to " + FILENAME);
        } catch (IOException e) {
            System.err.println("Error saving data: " + e.getMessage());
            e.printStackTrace();
        } finally {
            if (writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    // Reading from file
    public static void loadData() {
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new FileReader(FILENAME));
            System.out.println("\n=== Loading Saved Data ===");
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (FileNotFoundException e) {
            System.out.println("No saved data found. Starting fresh.");
        } catch (IOException e) {
            System.err.println("Error reading data: " + e.getMessage());
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

// ==================== UNIT 4: MULTITHREADING & GENERICS ====================

// Generic class
class DataAnalyzer<T extends Number> {
    private ArrayList<T> data;
    
    public DataAnalyzer() {
        data = new ArrayList<>();
    }
    
    public void addData(T value) {
        data.add(value);
    }
    
    // Generic method with bounded type
    public double calculateAverage() {
        if (data.isEmpty()) return 0.0;
        double sum = 0;
        for (T value : data) {
            sum += value.doubleValue();
        }
        return sum / data.size();
    }
    
    public T getMax() {
        if (data.isEmpty()) return null;
        T max = data.get(0);
        for (T value : data) {
            if (value.doubleValue() > max.doubleValue()) {
                max = value;
            }
        }
        return max;
    }
}

// Thread for automatic savings calculation
class SavingsCalculatorThread extends Thread {
    private SavingsAccount account;
    private volatile boolean running = true;
    
    public SavingsCalculatorThread(SavingsAccount account) {
        super("SavingsCalculator");
        this.account = account;
        setDaemon(true); // Daemon thread
    }
    
    @Override
    public void run() {
        System.out.println("Savings calculator thread started (Daemon)");
        while (running) {
            try {
                Thread.sleep(5000); // Sleep for 5 seconds
                synchronized (account) { // Thread synchronization
                    System.out.println("\n[Background] Checking savings...");
                    if (account.getBalance() > 0) {
                        account.applyInterest();
                    }
                }
            } catch (InterruptedException e) {
                System.out.println("Savings calculator interrupted");
                break;
            }
        }
    }
    
    public void stopCalculator() {
        running = false;
        this.interrupt();
    }
}

// Thread for budget monitoring
class BudgetMonitorThread implements Runnable {
    private ArrayList<Budget> budgets;
    private volatile boolean running = true;
    
    public BudgetMonitorThread(ArrayList<Budget> budgets) {
        this.budgets = budgets;
    }
    
    @Override
    public void run() {
        System.out.println("Budget monitor thread started");
        while (running) {
            try {
                Thread.sleep(3000);
                synchronized (budgets) { // Thread synchronization
                    System.out.println("\n[Background] Monitoring budgets...");
                    for (Budget budget : budgets) {
                        if (budget.isOverBudget()) {
                            System.out.println("ALERT: " + budget.getCategory() + 
                                             " budget exceeded!");
                        }
                    }
                }
            } catch (InterruptedException e) {
                System.out.println("Budget monitor interrupted");
                break;
            }
        }
    }
    
    public void stopMonitoring() {
        running = false;
    }
}

// ==================== MAIN APPLICATION ====================

public class PersonalFinanceManager {
    
    public static void main(String[] args) {
        System.out.println("============================================");
        System.out.println("   PERSONAL FINANCE MANAGER APPLICATION    ");
        System.out.println("      Demonstrating All OOP Concepts       ");
        System.out.println("============================================\n");
        
        // Create accounts (Inheritance, Polymorphism)
        SavingsAccount savings = new SavingsAccount("John Doe", 1000.0, 5.0);
        CurrentAccount current = new CurrentAccount("Jane Smith", 500.0, 200.0);
        
        // Display account types (Polymorphism)
        savings.displayAccountType();
        current.displayAccountType();
        System.out.println("Total Accounts: " + Account.getTotalAccounts() + "\n");
        
        // Transaction management (Interface implementation)
        TransactionManager transactionManager = new TransactionManager();
        
        // ArrayList usage
        ArrayList<Budget> budgets = new ArrayList<>();
        budgets.add(new Budget("Food", 500.0));
        budgets.add(new Budget("Transport", 200.0));
        budgets.add(new Budget("Entertainment", 150.0));
        
        // Generic programming
        DataAnalyzer<Double> expenseAnalyzer = new DataAnalyzer<>();
        
        // Exception handling demonstration
        try {
            System.out.println("=== Transaction Processing ===");
            
            // Deposit operation
            savings.deposit(500.0);
            transactionManager.recordTransaction(
                new Transaction("DEPOSIT", 500.0, "Salary credit"));
            expenseAnalyzer.addData(500.0);
            
            // Withdrawal with exception handling
            try {
                savings.withdraw(200.0);
                transactionManager.recordTransaction(
                    new Transaction("WITHDRAWAL", 200.0, "ATM withdrawal"));
                budgets.get(0).addExpense(200.0); // Food expense
                expenseAnalyzer.addData(200.0);
            } catch (InsufficientFundsException e) {
                System.err.println("Transaction failed: " + e.getMessage());
                // Stack trace
                e.printStackTrace();
            }
            
            // Another transaction
            current.deposit(300.0);
            transactionManager.recordTransaction(
                new Transaction("DEPOSIT", 300.0, "Freelance payment"));
            
            // Withdrawal from current account
            current.withdraw(150.0);
            transactionManager.recordTransaction(
                new Transaction("WITHDRAWAL", 150.0, "Bill payment"));
            budgets.get(1).addExpense(150.0); // Transport expense
            expenseAnalyzer.addData(150.0);
            
            // Add more expenses for budget testing
            budgets.get(2).addExpense(140.0); // Entertainment
            expenseAnalyzer.addData(140.0);
            
        } catch (InsufficientFundsException e) {
            System.err.println("Error: " + e.getMessage());
        }
        
        // Display transaction history
        transactionManager.displayTransactionHistory();
        
        // Display budgets (Inner class usage)
        System.out.println("\n=== Budget Overview ===");
        for (Budget budget : budgets) {
            budget.displayBudget();
        }
        
        // Generic data analysis
        System.out.println("\n=== Expense Analysis (Generic Programming) ===");
        System.out.printf("Average transaction: $%.2f%n", expenseAnalyzer.calculateAverage());
        System.out.printf("Largest transaction: $%.2f%n", expenseAnalyzer.getMax());
        
        // File I/O operations
        System.out.println("\n=== File Operations ===");
        FileManager.saveData(transactionManager.getTransactions());
        FileManager.loadData();
        
        // Multithreading demonstration
        System.out.println("\n=== Starting Background Threads ===");
        
        // Create and start threads
        SavingsCalculatorThread savingsThread = new SavingsCalculatorThread(savings);
        BudgetMonitorThread budgetMonitor = new BudgetMonitorThread(budgets);
        Thread monitorThread = new Thread(budgetMonitor, "BudgetMonitor");
        
        savingsThread.start();
        monitorThread.start();
        
        // Let threads run for a while
        try {
            System.out.println("\nApplication running for 12 seconds...");
            System.out.println("(Background threads are calculating interest and monitoring budgets)\n");
            Thread.sleep(12000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        // Stop threads
        savingsThread.stopCalculator();
        budgetMonitor.stopMonitoring();
        
        try {
            savingsThread.join();
            monitorThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        // Final account status
        System.out.println("\n============================================");
        System.out.println("          FINAL ACCOUNT STATUS             ");
        System.out.println("============================================");
        System.out.printf("Savings Account Balance: $%.2f%n", savings.getBalance());
        System.out.printf("Current Account Balance: $%.2f%n", current.getBalance());
        
        System.out.println("\nApplication completed successfully!");
        System.out.println("All OOP concepts demonstrated!");
    }
}