ASSIGNMENT MOHAMED AMIN

src/Main.java

@@ -1,156 +1,69 @@
-import Lecture1_adt.*; // Import all classes from Lecture1_adt package to be used in this client code
-
 import java.util.Calendar;
-import java.util.GregorianCalendar;
-import java.util.ArrayList;
-import java.util.List;
-
-//TIP To <b>Run</b> code, press <shortcut actionId="Run"/> or
-// click the <icon src="AllIcons.Actions.Execute"/> icon in the gutter.
-/*
-* Client Code for accessing the Lecture1_adt.TransactionInterface.java module
- */
-public class Main {
-
-    public static void testTransaction1() {
-        Calendar d1 = new GregorianCalendar(); // d1 is an Object [Objects are Reference types]
-        Lecture1_adt.Transaction1 t1 = new Lecture1_adt.Transaction1(1000, d1); // amount and d1 are arguments
-
-        System.out.println(t1.toString());
-        System.out.println("Lecture1_adt.TransactionInterface Amount: \t " + t1.amount);
-        System.out.println("Lecture1_adt.TransactionInterface Date: \t " + t1.date);
-
-        // Please note that the Client Codes can access the data in the class directly through the dot operator
-        // This kind of exposure is a threat to both the Representation Independence and Preservation of Invariants
-    }
-
-
-    /** @return a transaction of same amount as t, one month later
-     * This is a PRODUCER of the class Lecture1_adt.Transaction2
-     * This code will help demostrate the Design exposures still present in transaction2 class
-     * */
 
-    public static Transaction2 makeNextPayment(Transaction2 t) {
-        Calendar d =  t.getDate();
-        d.add(Calendar.MONTH, 1);
-        return new Transaction2(t.getAmount(), d);
-    }
-
-    /*
-    Testing Transaction2 class
-     */
-    public static void testTransaction2() {
-
-        Calendar d1 = new GregorianCalendar();
+public class Main {
 
-        Lecture1_adt.Transaction2 t = new Lecture1_adt.Transaction2(1000, d1);
+    public static void main(String[] args) {
 
-        Lecture1_adt.Transaction2 modified_t = makeNextPayment(t);
+        BankAccount acc =
+                new BankAccount("ACC001", 1000);
 
-        System.out.println("\n\nState of the Object T1 After Client Code Tried to Change the Amount");
-        System.out.println("Lecture1_adt.TransactionInterface Amount: \t "+modified_t.getAmount());
-        System.out.println("Lecture1_adt.TransactionInterface Date: \t "+modified_t.getDate().getTime());
+        Calendar today = Calendar.getInstance();
 
-        System.out.println("\n\nHow does T2 Look Like?????");
-        System.out.println("Lecture1_adt.TransactionInterface Amount: \t "+modified_t.getAmount());
-        System.out.println("Lecture1_adt.TransactionInterface Date: \t "+modified_t.getDate().getTime());
+        DepositTransaction deposit =
+                new DepositTransaction(
+                        500,
+                        today,
+                        "D001");
 
-        /* Please note that Although we have solved the problem of Transaction1
-        * And client code can no longer use the dot (.) operator to directly access the data
-        * There is still some exposure especially if we pass an object of a previous Transaction2 to create a new Transaction2 object
-         */
+        WithdrawalTransaction withdrawal =
+                new WithdrawalTransaction(
+                        300,
+                        today,
+                        "W001");
 
-    }
+        // Test Deposit
+        deposit.printTransactionDetails();
+        deposit.apply(acc);
+        acc.printAccount();
 
+        System.out.println();
 
-    /** @return a list of 12 monthly payments of identical amounts
-     * This code will help demostrate the Design exposures still present in transaction3 class
-     * */
-    public static List<Transaction3> makeYearOfPayments (int amount) throws NullPointerException {
+        // Test Withdrawal
+        try {
 
-        List<Transaction3> listOfTransaction3s = new ArrayList<Transaction3>();
-        Calendar date = new GregorianCalendar(2024, Calendar.JANUARY, 3);
+            withdrawal.printTransactionDetails();
+            withdrawal.apply(acc);
 
+        } catch (InsufficientFundsException e) {
 
-        for (int i = 0; i < 12; i++) {
-            listOfTransaction3s.add(new Transaction3(amount, date));
-            date.add(Calendar.MONTH, 1);
+            System.out.println(e.getMessage());
         }
-        return listOfTransaction3s;
-    }
 
-    /*
-    Testing Transaction3 class
-     */
-    public static void testTransaction3() {
+        acc.printAccount();
 
-        List<Transaction3> allPaymentsIn2024 = makeYearOfPayments(1000);
+        System.out.println();
 
-        for (Transaction3 t3 : allPaymentsIn2024) {
-
-            // Display all the 12 Transactions
-            for (Transaction3 transact : allPaymentsIn2024) {
-                System.out.println("\n\n  ::::::::::::::::::::::::::::::::::::::::::::\n");
-                System.out.println("Lecture1_adt.TransactionInterface Amount: \t "+transact.getAmount());
-                System.out.println("Lecture1_adt.TransactionInterface Date: \t "+transact.getDate().getTime());
-            }
-        }
-
-        /* Please Check all the 12 transactions displayed and hwo their dates look like
-         * Note that Although Transaction3 class resolves to an extent the exposure in Transaction2 class
-         * There is still some exposure especially if we pass an object of a previous Transaction3 to create a
-         * new Transaction3 object
-         */
-    }
+        // Reverse Withdrawal
+        withdrawal.reverse();
+        acc.printAccount();
 
+        System.out.println();
 
-    /** @return a list of 12 monthly payments of identical amounts
-     * This code Show that by judicious copying and defensive programming we eliminate the exposure in Transaction3
-     * As defined in the constructor of Transaction4 class
-     * */
+        // Polymorphism
+        BaseTransaction bt;
 
-    public static List<Transaction4> makeYearOfPaymentsFinal (int amount) throws NullPointerException {
+        bt = deposit;
+        bt.apply(acc);
 
-        List<Transaction4> listOfTransaction4s = new ArrayList<Transaction4>();
-        Calendar date = new GregorianCalendar(2024, Calendar.JANUARY, 3);
+        bt = withdrawal;
 
-
-        for (int i = 0; i < 12; i++) {
-            listOfTransaction4s.add(new Transaction4(amount, date));
-            date.add(Calendar.MONTH, 1);
+        try {
+            bt.apply(acc);
         }
-        return listOfTransaction4s;
-    }
-
-    /*
-    Testing Transaction3 class
-     */
-    public static void testTransaction4() {
-
-        /*
-         * Call the function to make all the Twelve transaction in a year of our business
-         */
-
-        List<Transaction4> transactionsIn2024 = makeYearOfPaymentsFinal(1200);
-
-        // Display all the 12 Transactions
-        for (Transaction4 transact : transactionsIn2024) {
-            System.out.println("\n\n  ::::::::::::::::::::::::::::::::::::::::::::\n");
-            System.out.println("Lecture1_adt.TransactionInterface Amount: \t "+transact.getAmount());
-            System.out.println("Lecture1_adt.TransactionInterface Date: \t "+transact.getDate().getTime());
+        catch (Exception e) {
+            System.out.println(e.getMessage());
         }
 
-        // Please Take a look at all the 12 transaction now and compare with the outputs of the Transaction3 class
-    }
-
-
-    public static void main(String[] args) {
-        // This is the client code
-        // Uncomment the following lines to test the class which you would like to test
-
-        // testTransaction1()
-        // testTransaction2()
-        // testTransaction3()
-        // testTransaction4()
+        acc.printAccount();
     }
-}
+}

src/basetransactionclass

@@ -0,0 +1,41 @@
+import java.util.Calendar;
+
+public class BaseTransaction implements TransactionInterface {
+
+    protected double amount;
+    protected Calendar date;
+    protected String transactionID;
+
+    public BaseTransaction(double amount, Calendar date, String transactionID) {
+        this.amount = amount;
+        this.date = date;
+        this.transactionID = transactionID;
+    }
+
+    @Override
+    public double getAmount() {
+        return amount;
+    }
+
+    @Override
+    public Calendar getDate() {
+        return date;
+    }
+
+    @Override
+    public String getTransactionID() {
+        return transactionID;
+    }
+
+    @Override
+    public void printTransactionDetails() {
+        System.out.println("Transaction ID: " + transactionID);
+        System.out.println("Amount: " + amount);
+        System.out.println("Date: " + date.getTime());
+    }
+
+    @Override
+    public void apply(BankAccount ba) {
+        System.out.println("Generic transaction applied.");
+    }
+}

src/deposittransactionclass

@@ -0,0 +1,20 @@
+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(amount);
+        System.out.println("Deposit successful.");
+    }
+
+    @Override
+    public void printTransactionDetails() {
+        System.out.println("=== Deposit Transaction ===");
+        super.printTransactionDetails();
+    }
+}

src/insufficientfundsexception

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

src/reversewithdrawal

@@ -0,0 +1,13 @@
+public boolean reverse() {
+
+    if (accountUsed == null) {
+        return false;
+    }
+
+    accountUsed.deposit(amount);
+
+    System.out.println(
+            "Withdrawal reversed successfully.");
+
+    return true;
+}

src/withdrawaltransactionclass

@@ -0,0 +1,90 @@
+import java.util.Calendar;
+
+public class WithdrawalTransaction extends BaseTransaction {
+
+    private BankAccount accountUsed;
+    private double amountNotWithdrawn = 0;
+
+    public WithdrawalTransaction(double amount,
+                                 Calendar date,
+                                 String transactionID) {
+        super(amount, date, transactionID);
+    }
+
+    @Override
+    public void apply(BankAccount ba)
+            throws InsufficientFundsException {
+
+        if (ba.getBalance() < amount) {
+            throw new InsufficientFundsException(
+                    "Insufficient funds.");
+        }
+
+        ba.withdraw(amount);
+        accountUsed = ba;
+
+        System.out.println("Withdrawal successful.");
+    }
+
+    // Overloaded apply method
+    public void apply(BankAccount ba, boolean availableBalanceMode) {
+
+        try {
+
+            if (ba.getBalance() <= 0) {
+                throw new InsufficientFundsException(
+                        "Account balance is zero.");
+            }
+
+            if (ba.getBalance() < amount) {
+
+                amountNotWithdrawn =
+                        amount - ba.getBalance();
+
+                ba.withdraw(ba.getBalance());
+
+                System.out.println(
+                        "Partial withdrawal completed.");
+            }
+            else {
+                ba.withdraw(amount);
+            }
+
+            accountUsed = ba;
+        }
+
+        catch (InsufficientFundsException e) {
+            System.out.println(e.getMessage());
+        }
+
+        finally {
+            System.out.println(
+                    "Withdrawal process completed.");
+        }
+    }
+
+    public double getAmountNotWithdrawn() {
+        return amountNotWithdrawn;
+    }
+
+    public boolean reverse() {
+
+        if (accountUsed == null) {
+            return false;
+        }
+
+        accountUsed.deposit(amount);
+
+        System.out.println(
+                "Withdrawal reversed successfully.");
+
+        return true;
+    }
+
+    @Override
+    public void printTransactionDetails() {
+        System.out.println(
+                "=== Withdrawal Transaction ===");
+        super.printTransactionDetails();
+    }
+}