Testing

src/AP-Assignment-main/BankAccount.java

@@ -0,0 +1,25 @@
+public class BankAccount {
+    private String accountNumber;
+    private double balance;
+
+    public BankAccount(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) {
+        this.balance += amount;
+    }
+
+    public void withdraw(double amount) {
+        this.balance -= amount;
+    }
+}

src/AP-Assignment-main/BaseTransaction.java

@@ -0,0 +1,38 @@
+import java.util.Calendar;
+
+public abstract class BaseTransaction implements TransactionInterface {
+    private double amount;
+    private Calendar date;
+    private String transactionID;
+
+    public BaseTransaction(double amount, Calendar date, String transactionID) {
+        this.amount = amount;
+        this.date = date;
+        this.transactionID = transactionID;
+    }
+
+    @Override
+    public double getAmount() {
+        return this.amount;
+    }
+
+    @Override
+    public Calendar getDate() {
+        return this.date;
+    }
+
+    @Override
+    public String getTransactionID() {
+        return this.transactionID;
+    }
+
+    @Override
+    public void printTransactionDetails() {
+        System.out.println("Transaction ID: " + transactionID);
+        System.out.println("Amount: " + amount);
+        System.out.println("Date: " + date.getTime());
+    }
+
+    // Abstract method for applying a transaction on a bank account
+    public abstract void apply(BankAccount ba);
+}

src/AP-Assignment-main/DepositTransaction.java

@@ -0,0 +1,12 @@
+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("Deposited " + getAmount() + " to account " + ba.getAccountNumber());
+    }
+}

src/AP-Assignment-main/InsufficientFundsException.java

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

src/AP-Assignment-main/Main.java

@@ -0,0 +1,26 @@
+import java.util.Calendar;
+
+public class Main {
+    public static void main(String[] args) {
+        BankAccount account = new BankAccount("12345", 500.0);
+
+        // Create a DepositTransaction
+        Calendar depositDate = Calendar.getInstance();
+        DepositTransaction deposit = new DepositTransaction(200.0, depositDate, "D123");
+        deposit.printTransactionDetails();
+        deposit.apply(account);  // Apply deposit transaction
+
+        // Create a WithdrawalTransaction
+        Calendar withdrawDate = Calendar.getInstance();
+        WithdrawalTransaction withdrawal = new WithdrawalTransaction(100.0, withdrawDate, "W123");
+        withdrawal.printTransactionDetails();
+        try {
+            withdrawal.apply(account);  // Apply withdrawal transaction
+        } catch (InsufficientFundsException e) {
+            System.out.println(e.getMessage());
+        }
+
+        // Reverse the withdrawal
+        withdrawal.reverse(account);  // Reverse the transaction
+    }
+}

src/AP-Assignment-main/README.md

@@ -0,0 +1,15 @@
+# AP-Assignment 1
+Question 1 - Extending Interface in Concrete Class
+Question 2 - Differentiate functionality of DepositTransaction 
+and WithdrawalTransaction 
+Question 3 - Exception Handling and Client Codes
+Question 4 - Writing the Client Code
+
+files;
+TransactionInterface.java
+BaseTransaction.java
+DepositTransaction.java
+WithdrawalTransaction.java
+InsufficientFundsException.java
+BankAccount.java
+Main.java

src/AP-Assignment-main/TransactionInterface.java

@@ -0,0 +1,9 @@
+import java.util.Calendar;
+
+public interface TransactionInterface {
+    double getAmount(); // Get the transaction amount
+    Calendar getDate(); // Get the transaction date
+    String getTransactionID(); // Get the transaction ID
+    void printTransactionDetails(); // Print transaction details
+    void apply(BankAccount ba); // Apply transaction to the bank account
+}

src/AP-Assignment-main/WithdrawalTransaction.java

@@ -0,0 +1,23 @@
+public 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()) {
+            ba.withdraw(getAmount());
+            System.out.println("Withdrew " + getAmount() + " from account " + ba.getAccountNumber());
+        } else {
+            throw new InsufficientFundsException("Insufficient funds for withdrawal.");
+        }
+    }
+
+    // Method to reverse a withdrawal transaction
+    public boolean reverse(BankAccount ba) {
+        ba.deposit(getAmount());  // Reverse by depositing the same amount back
+        System.out.println("Reversed withdrawal of " + getAmount() + " from account " + ba.getAccountNumber());
+        return true;
+    }
+}

src/farid/BankAccount.java

@@ -0,0 +1,19 @@
+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/farid/BaseTransaction.java

@@ -0,0 +1,47 @@
+import java.util.Calendar;
+
+public class BaseTransaction implements TransactionInterface {
+    protected double amount;
+    protected Calendar date;
+    protected String transactionID;
+
+    // Constructor
+    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;
+    }
+
+    // Common method to print transaction details
+    public void printTransactionDetails() {
+        System.out.println("Transaction ID: " + transactionID);
+        System.out.println("Amount: " + amount);
+        System.out.println("Date: " + date.getTime());
+    }
+
+    // Method to apply the transaction (meant to be overridden by subclasses)
+    public void apply(BankAccount ba) {
+        System.out.println("Applying transaction...");
+    }
+
+    // Default reverse method (can be overridden if needed)
+    public boolean reverse(BankAccount ba) {
+        System.out.println("Reversal not supported for this transaction.");
+        return false;
+    }
+}

src/farid/DepositTransaction.java

@@ -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: " + amount);
+    }
+
+    @Override
+    public boolean reverse(BankAccount ba) {
+        System.out.println("Deposits cannot be reversed.");
+        return false;
+    }
+}

src/farid/InsufficientFundsException.java

@@ -0,0 +1,6 @@
+public class InsufficientFundsException extends Exception {
+    public InsufficientFundsException(String message) {
+        super(message);
+    }
+}
+//insufficient Funds

src/farid/Main.java

@@ -0,0 +1,26 @@
+import java.util.Calendar;
+
+public class Main {
+    public static void main(String[] args) {
+        BankAccount account = new BankAccount(1000.0);
+        Calendar date = Calendar.getInstance();
+
+        // Create DepositTransaction
+        DepositTransaction deposit = new DepositTransaction(500.0, date, "D123");
+        deposit.apply(account);
+        deposit.printTransactionDetails();
+
+        // Create WithdrawalTransaction
+        WithdrawalTransaction withdrawal = new WithdrawalTransaction(300.0, date, "W456");
+        withdrawal.apply(account);
+        withdrawal.printTransactionDetails();
+
+        // Test reversal of withdrawal
+        withdrawal.reverse(account);
+
+        // Try to reverse deposit
+        deposit.reverse(account);
+
+        System.out.println("Final Balance: " + account.getBalance());
+    }
+}

src/farid/TransactionInterface.java

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

src/farid/WithdrawalTransaction.java

@@ -0,0 +1,28 @@
+import java.util.Calendar;
+
+public class WithdrawalTransaction extends BaseTransaction {
+
+    public WithdrawalTransaction(double amount, Calendar date, String transactionID) {
+        super(amount, date, transactionID);
+    }
+
+    @Override
+    public void apply(BankAccount ba) {
+        try {
+            if (ba.getBalance() < amount) {
+                throw new InsufficientFundsException("Insufficient funds for withdrawal.");
+            }
+            ba.withdraw(amount);
+            System.out.println("Withdrawal successful: " + amount);
+        } catch (InsufficientFundsException e) {
+            System.out.println(e.getMessage());
+        }
+    }
+
+    @Override
+    public boolean reverse(BankAccount ba) {
+        ba.deposit(amount);
+        System.out.println("Withdrawal reversed: " + amount);
+        return true;
+    }
+}