ap assignment on ADTS

src/Assignment1/BankAccount.java

@@ -0,0 +1,21 @@
+package Assignment1;
+
+public class BankAccount {
+    private double balance;
+
+    public BankAccount(double balance) {
+        this.balance = balance;
+    }
+
+    public double getBalance() {
+        return balance;
+    }
+
+    public void deposit(double amount) {
+        balance += amount;
+    }
+
+    public void withdraw(double amount) {
+        balance -= amount;
+    }
+}

src/Assignment1/BaseTransaction.java

@@ -0,0 +1,53 @@
+package Assignment1;
+
+import Lecture4_interfaces_abstract_classes.TransactionInterface;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Calendar;
+public class BaseTransaction  implements TransactionInterface {
+    private final double amount;
+    private final Calendar date;
+    private final String transactionID;
+    protected BankAccount changedAccount;
+    protected boolean isChanged = false;
+
+    public BaseTransaction(double amount, @NotNull Calendar date, String transactionID) {
+        this.amount = amount;
+        this.date = (Calendar) date.clone();
+        int uniq = (int) (Math.random() * 10000);
+        this.transactionID = date.toString() + uniq;
+    }
+
+    public double getAmount() {
+        return amount;
+    }
+
+    public Calendar getDate() {
+        return (Calendar) date.clone();
+    }
+
+    public String getTransactionID() {
+        return  transactionID;
+    }
+
+    public void printTransactionDetails() {
+        System.out.println("Transaction Details:");
+        System.out.println("ID: " + getTransactionID());
+        System.out.println("Amount: $" + getAmount());
+        System.out.println("Date: " + getDate().getTime());
+    }
+    public void apply(BankAccount ba) throws InsufficientFundsException {
+        System.out.println("Processing transaction: " + transactionID);
+        System.out.println("Current balance before transaction: $" + ba.getBalance());
+        this.changedAccount = ba;
+    }
+    @Override
+    public boolean reverse() {
+        System.out.println("Base transactions cannot be reversed");
+        return false;
+    }
+}
+
+
+
+

src/Assignment1/DepositTransaction.java

@@ -0,0 +1,15 @@
+package Assignment1;
+
+import java.util.Calendar;
+public class DepositTransaction  extends BaseTransaction {
+
+        public DepositTransaction(double amount, Calendar date, String transactionID) {
+            super(amount, date, transactionID);
+        }
+
+        @Override
+        public void apply(BankAccount ba) {
+            ba.deposit(getAmount());
+            System.out.println("Deposit completed successfully. New balance: ").toString();
+        }
+}

src/Assignment1/InsufficientFundsException.java

@@ -0,0 +1,10 @@
+package Assignment1;
+
+public class InsufficientFundsException extends Exception {
+    public InsufficientFundsException() {
+        public InsufficientFundsException(String message);
+        {
+            super(message);
+        }
+    }
+}

src/Assignment1/TransactionInterface.java

@@ -0,0 +1,12 @@
+package Assignment1;
+
+import java.util.Calendar;
+public interface TransactionInterface {
+    double getAmount();
+
+    Calendar getDate();
+    String getTransactionID();
+    void printTransactionDetails();
+    void apply(BankAccount ba);
+    boolean reverse();
+}

src/Assignment1/WithdrawalTransaction.java

@@ -0,0 +1,45 @@
+package Assignment1;
+
+import java.util.Calendar;
+
+class WithdrawalTransaction extends BaseTransaction {
+    public WithdrawalTransaction(double amount, Calendar date, String transactionID) {
+        super(amount, date, transactionID);
+    }
+
+    @Override
+    public void apply(BankAccount ba) throws InsufficientFundsException {
+        if (ba.getBalance() < getAmount()) {
+            throw new InsufficientFundsException("Insufficient funds in account");
+        }
+        ba.withdraw(getAmount());
+        System.out.println("Withdrawal successful. New balance: " + ba.getBalance());
+    }
+
+    public boolean reverse(BankAccount ba) {
+        ba.deposit(getAmount());
+        System.out.println("Withdrawal reversed. New balance: " + ba.getBalance());
+        return true;
+    }
+
+    public void apply(BankAccount ba, boolean forceWithdrawal) {
+        try {
+            if (ba.getBalance() < getAmount()) {
+                if (forceWithdrawal) {
+                    double amountWithdrawn = ba.getBalance();
+                    ba.withdraw(amountWithdrawn);
+                    System.out.println("Withdrew " + amountWithdrawn + ". Remaining amount not withdrawn: " + (getAmount() - amountWithdrawn));
+                } else {
+                    throws new InsufficientFundsException("Insufficient funds in account");
+                }
+            } else {
+                ba.withdraw(getAmount());
+                System.out.println("Withdrawal successful. New balance: " + ba.getBalance());
+            }
+        } catch (InsufficientFundsException e) {
+            System.out.println(e.getMessage());
+        } finally {
+            System.out.println("Withdrawal operation completed.");
+        }
+    }
+}

src/Assignment1/main.java

@@ -0,0 +1,41 @@
+package Assignment1;
+import java.util.Calendar;
+
+// Main class to test the functionality
+public class Main {
+    public static void main(String[] args) {
+        BankAccount ba = new BankAccount(1000);
+
+        // Test DepositTransaction
+        DepositTransaction dt = new DepositTransaction(500, Calendar.getInstance(), "DT001");
+        dt.printTransactionDetails();
+        dt.apply(ba);
+
+        // Test WithdrawalTransaction
+        WithdrawalTransaction wt = new WithdrawalTransaction(200, Calendar.getInstance());
+        wt.printTransactionDetails();
+        try {
+            wt.apply(ba);
+        }
+        catch (InsufficientFundsException e) {
+            System.out.println(e.getMessage());
+        }
+        wt.apply(ba, true);
+
+        // Test WithdrawalTransaction reversal
+        wt.reverse(ba);
+
+
+        BaseTransaction bt = new DepositTransaction(300, Calendar.getInstance(), "DT002");
+        bt.printTransactionDetails();
+        bt.apply(ba);
+
+        bt = new WithdrawalTransaction(400, Calendar.getInstance());
+        bt.printTransactionDetails();
+        try {
+            bt.apply(ba);
+        } catch (InsufficientFundsException e) {
+            System.out.println(e.getMessage());
+        }
+    }
+}

src/Lecture4_interfaces_abstract_classes/TransactionInterface.java

@@ -16,6 +16,7 @@ public interface TransactionInterface {
     // Method to get a unique identifier for the transaction
     String getTransactionID();
 
+    boolean reverse();
 }