From d6a6c84d823706a81e3bda0a281d12a1d2e32dfa Mon Sep 17 00:00:00 2001 From: yourboykungu Date: Sat, 30 Nov 2024 03:13:49 +0300 Subject: [PATCH 1/2] final assignment --- src/Lecture1_adt/Transaction5.java | 18 ++++++ .../BankAccount.java | 21 ++++++- .../BaseTransaction.java | 45 ++++++++------ ...rasaction.java => DepositTransaction.java} | 4 +- .../ReversalTransaction.java | 29 +++++++++ .../WithdrawalTransaction.java | 61 +++++++++++-------- src/Main.java | 53 +++++++++++----- 7 files changed, 167 insertions(+), 64 deletions(-) create mode 100644 src/Lecture1_adt/Transaction5.java rename src/Lecture4_interfaces_abstract_classes/{DepositTrasaction.java => DepositTransaction.java} (84%) create mode 100644 src/Lecture4_interfaces_abstract_classes/ReversalTransaction.java diff --git a/src/Lecture1_adt/Transaction5.java b/src/Lecture1_adt/Transaction5.java new file mode 100644 index 0000000..6554eb6 --- /dev/null +++ b/src/Lecture1_adt/Transaction5.java @@ -0,0 +1,18 @@ +package Lecture1_adt; + +import java.util.Calendar; + +public class Transaction5 { + public int amount; + private Calendar date; + + + public int getAmount() { + return amount; // Because we are dealing with Value types we need not worry about what we return + } + + public Calendar getDate() { +// return date; // Because we are dealing with Reference types we need to judiciously copy what our getters return + return (Calendar) date.clone(); // Defensive copying or Judicious Copying + } +} \ No newline at end of file diff --git a/src/Lecture4_interfaces_abstract_classes/BankAccount.java b/src/Lecture4_interfaces_abstract_classes/BankAccount.java index 28d0d07..b881a43 100644 --- a/src/Lecture4_interfaces_abstract_classes/BankAccount.java +++ b/src/Lecture4_interfaces_abstract_classes/BankAccount.java @@ -2,15 +2,32 @@ public class BankAccount { private double balance; - public BankAccount(double balance) { - this.balance = balance; + + public BankAccount(double initialBalance) { + this.balance = initialBalance; } + // Getter for balance public double getBalance() { return balance; } + // Setter for balance public void setBalance(double balance) { this.balance = balance; } + + // Method to print the current balance + public void printBalance() { + System.out.println("Current Balance: " + getBalance()); + } + + // Method to apply a transaction (deposit or withdrawal) + public void applyTransaction(BaseTransaction transaction) { + if (transaction instanceof WithdrawalTransaction) { + this.balance -= transaction.getAmount(); + } else if (transaction instanceof DepositTransaction) { + this.balance += transaction.getAmount(); + } + } } diff --git a/src/Lecture4_interfaces_abstract_classes/BaseTransaction.java b/src/Lecture4_interfaces_abstract_classes/BaseTransaction.java index ed81eb8..b5e9d8d 100644 --- a/src/Lecture4_interfaces_abstract_classes/BaseTransaction.java +++ b/src/Lecture4_interfaces_abstract_classes/BaseTransaction.java @@ -5,7 +5,7 @@ import java.util.Calendar; public abstract class BaseTransaction implements TransactionInterface { - private final int amount; + private final double amount; private final Calendar date; private final String transactionID; @@ -17,35 +17,46 @@ public abstract class BaseTransaction implements TransactionInterface { * Instialises the field, attributes of a transaction * Creates a object of this */ - public BaseTransaction(int amount, @NotNull Calendar date) { + public BaseTransaction(double amount, @NotNull Calendar date) { this.amount = amount; - this.date = (Calendar) date.clone(); - int uniq = (int) Math.random()*10000; - transactionID = date.toString()+uniq; + this.date = (Calendar) date.clone();//defensive copy of date + this.transactionID = generateTransactionID(date); + } + /** + * Generates a unique transaction ID based on the date and a random value + * @param date: The transaction date to be used for ID generation + * @return A unique transaction ID string + */ + private String generateTransactionID(Calendar date) { + int uniq = (int) (Math.random() * 10000); + return date.getTime().toString() + "-" + uniq; // Combine date string and random number } /** - * getAmount() - * @return integer + * Gets the transaction amount + * @return The transaction amount as double */ public double getAmount() { - return amount; // Because we are dealing with Value types we need not worry about what we return + return amount; } /** - * getDate() - * @return Calendar Object + * Gets the transaction date + * @return A defensive copy of the transaction date */ public Calendar getDate() { -// return date; // Because we are dealing with Reference types we need to judiciously copy what our getters return - return (Calendar) date.clone(); // Defensive copying or Judicious Copying + return (Calendar) date.clone(); // Defensive copying to avoid external modification } - // Method to get a unique identifier for the transaction - public String getTransactionID(){ - return transactionID; + /** + * Gets the unique transaction ID + * @return The transaction ID string + */ + public String getTransactionID() { + return transactionID; } - // Method to print a transaction receipt or details + + // Abstract methods that must be implemented by subclasses public abstract void printTransactionDetails(); public abstract void apply(BankAccount ba); -} +} \ No newline at end of file diff --git a/src/Lecture4_interfaces_abstract_classes/DepositTrasaction.java b/src/Lecture4_interfaces_abstract_classes/DepositTransaction.java similarity index 84% rename from src/Lecture4_interfaces_abstract_classes/DepositTrasaction.java rename to src/Lecture4_interfaces_abstract_classes/DepositTransaction.java index 81afab5..25d62be 100644 --- a/src/Lecture4_interfaces_abstract_classes/DepositTrasaction.java +++ b/src/Lecture4_interfaces_abstract_classes/DepositTransaction.java @@ -4,8 +4,8 @@ import java.util.Calendar; -public class DepositTrasaction extends BaseTransaction { - public DepositTrasaction(int amount, @NotNull Calendar date){ +public class DepositTransaction extends BaseTransaction { + public DepositTransaction(int amount, @NotNull Calendar date){ super(amount, date); } private boolean checkDepositAmount(int amt){ diff --git a/src/Lecture4_interfaces_abstract_classes/ReversalTransaction.java b/src/Lecture4_interfaces_abstract_classes/ReversalTransaction.java new file mode 100644 index 0000000..52025a2 --- /dev/null +++ b/src/Lecture4_interfaces_abstract_classes/ReversalTransaction.java @@ -0,0 +1,29 @@ +package Lecture4_interfaces_abstract_classes; + +import org.jetbrains.annotations.NotNull; +import java.util.Calendar; + +public class ReversalTransaction extends BaseTransaction { + + private boolean isReversed = true; + + // Change the constructor to accept a double amount + public ReversalTransaction(double amount, @NotNull Calendar date) { + super(amount, date); + } + + public void apply(BankAccount ba) { + double currentBalance = ba.getBalance(); + double amountToReverse = getAmount(); + ba.setBalance(currentBalance + amountToReverse); + System.out.println("Reversal of " + amountToReverse + " applied successfully."); + } + + public void printTransactionDetails() { + System.out.println("Reversal Transaction:"); + System.out.println("Amount: " + getAmount()); + System.out.println("Date: " + getDate().getTime()); + System.out.println("Transaction ID: " + getTransactionID()); + System.out.println("Reversed: " + (isReversed ? "Yes" : "No")); + } +} diff --git a/src/Lecture4_interfaces_abstract_classes/WithdrawalTransaction.java b/src/Lecture4_interfaces_abstract_classes/WithdrawalTransaction.java index face5b6..de62fa9 100644 --- a/src/Lecture4_interfaces_abstract_classes/WithdrawalTransaction.java +++ b/src/Lecture4_interfaces_abstract_classes/WithdrawalTransaction.java @@ -1,45 +1,52 @@ package Lecture4_interfaces_abstract_classes; import org.jetbrains.annotations.NotNull; - import java.util.Calendar; public class WithdrawalTransaction extends BaseTransaction { + public WithdrawalTransaction(int amount, @NotNull Calendar date) { super(amount, date); } - private boolean checkDepositAmount(int amt) { - if (amt < 0) { - return false; - } else { - return true; - } + private boolean checkWithdrawalAmount(double amt) { + return amt >= 0; + } + @Override + public void apply(BankAccount ba) { + apply(ba, "Standard Withdrawal"); // Default to "Standard Withdrawal" type } - // Method to reverse the transaction - public boolean reverse() { - return true; - } // return true if reversal was successful + public void apply(BankAccount ba, String withdrawalType) { + double currentBalance = ba.getBalance(); - // Method to print a transaction receipt or details - public void printTransactionDetails() { - System.out.println("Deposit Trasaction: " + this.toString()); - } + if (!checkWithdrawalAmount(getAmount())) { + System.out.println("Invalid withdrawal amount."); + return; + } - /* - Oportunity for assignment: implementing different form of withdrawal - */ - public void apply(BankAccount ba) { - double curr_balance = ba.getBalance(); - if (curr_balance > getAmount()) { - double new_balance = curr_balance - getAmount(); - ba.setBalance(new_balance); + if (currentBalance >= getAmount()) { + double newBalance = currentBalance - getAmount(); + ba.setBalance(newBalance); + System.out.println("Withdrawal of " + getAmount() + " applied successfully."); + } else { + System.out.println("Insufficient funds for withdrawal."); } } - /* - Assignment 1 Q3: Write the Reverse method - a method unique to the WithdrawalTransaction Class - */ -} + public void printTransactionDetails() { + System.out.println("Withdrawal Transaction:"); + System.out.println("Amount: " + getAmount()); + System.out.println("Date: " + getDate().getTime()); + System.out.println("Transaction ID: " + getTransactionID()); + } + + // Reverse method to create a ReversalTransaction + public ReversalTransaction reverse(BankAccount ba) { + double currentBalance = ba.getBalance(); + ba.setBalance(currentBalance + getAmount()); + // Create a reversal transaction with a double amount + return new ReversalTransaction(this.getAmount(), this.getDate()); + } +} \ No newline at end of file diff --git a/src/Main.java b/src/Main.java index 584a048..eae2fbb 100644 --- a/src/Main.java +++ b/src/Main.java @@ -1,4 +1,5 @@ import Lecture1_adt.*; // Import all classes from Lecture1_adt package to be used in this client code +import Lecture4_interfaces_abstract_classes.*; import java.util.Calendar; import java.util.GregorianCalendar; @@ -44,7 +45,6 @@ public static void testTransaction2() { Calendar d1 = new GregorianCalendar(); Lecture1_adt.Transaction2 t = new Lecture1_adt.Transaction2(1000, d1); - Lecture1_adt.Transaction2 modified_t = makeNextPayment(t); System.out.println("\n\nState of the Object T1 After Client Code Tried to Change the Amount"); @@ -70,8 +70,6 @@ public static List makeYearOfPayments (int amount) throws NullPoin List listOfTransaction3s = new ArrayList(); Calendar date = new GregorianCalendar(2024, Calendar.JANUARY, 3); - - for (int i = 0; i < 12; i++) { listOfTransaction3s.add(new Transaction3(amount, date)); date.add(Calendar.MONTH, 1); @@ -83,11 +81,8 @@ public static List makeYearOfPayments (int amount) throws NullPoin Testing Transaction3 class */ public static void testTransaction3() { - List allPaymentsIn2024 = makeYearOfPayments(1000); - for (Transaction3 t3 : allPaymentsIn2024) { - // Display all the 12 Transactions for (Transaction3 transact : allPaymentsIn2024) { System.out.println("\n\n ::::::::::::::::::::::::::::::::::::::::::::\n"); @@ -114,7 +109,6 @@ public static List makeYearOfPaymentsFinal (int amount) throws Nul List listOfTransaction4s = new ArrayList(); Calendar date = new GregorianCalendar(2024, Calendar.JANUARY, 3); - for (int i = 0; i < 12; i++) { listOfTransaction4s.add(new Transaction4(amount, date)); date.add(Calendar.MONTH, 1); @@ -126,21 +120,46 @@ public static List makeYearOfPaymentsFinal (int amount) throws Nul Testing Transaction3 class */ public static void testTransaction4() { - - /* - * Call the function to make all the Twelve transaction in a year of our business - */ - List 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()); } + } + // New method to test Withdrawal and Reversal Transactions with BankAccount + public static void testWithdrawalAndReversal() { + // Create a BankAccount with an initial balance of 5000 + BankAccount bankAccount = new BankAccount(5000); + bankAccount.printBalance(); // Initial balance - // Please Take a look at all the 12 transaction now and compare with the outputs of the Transaction3 class + // Create and apply a standard withdrawal + Calendar d1 = new GregorianCalendar(); + WithdrawalTransaction standardWithdrawal = new WithdrawalTransaction(1000, d1); + standardWithdrawal.apply(bankAccount, "Standard Withdrawal"); + System.out.println("\nAfter Standard Withdrawal:"); + bankAccount.printBalance(); // Balance after standard withdrawal + + // Create and apply an ATM withdrawal + WithdrawalTransaction atmWithdrawal = new WithdrawalTransaction(500, d1); + atmWithdrawal.apply(bankAccount, "ATM Withdrawal"); + System.out.println("\nAfter ATM Withdrawal:"); + bankAccount.printBalance(); // Balance after ATM withdrawal + + // Create and apply an online withdrawal + WithdrawalTransaction onlineWithdrawal = new WithdrawalTransaction(200, d1); + onlineWithdrawal.apply(bankAccount, "Online Withdrawal"); + System.out.println("\nAfter Online Withdrawal:"); + bankAccount.printBalance(); // Balance after online withdrawal + + + // Create a reversal of the withdrawal transaction + ReversalTransaction reversal = standardWithdrawal.reverse(bankAccount); + + // Apply the reversal transaction to the account + bankAccount.applyTransaction(reversal); + System.out.println("\nAfter Reversal:"); + bankAccount.printBalance(); // Balance after reversal } @@ -148,9 +167,11 @@ 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() + //testTransaction1(); // testTransaction2() // testTransaction3() // testTransaction4() + + testWithdrawalAndReversal(); } } \ No newline at end of file From 833e5cdf8e7606aeab8e8bc1a5db9ac007592fb7 Mon Sep 17 00:00:00 2001 From: yourboykungu Date: Mon, 13 Jan 2025 18:19:45 +0300 Subject: [PATCH 2/2] assingment redo --- src/Assignment1/BankAccount.java | 21 +++++++ src/Assignment1/BaseTransaction.java | 53 ++++++++++++++++ src/Assignment1/DepositTransaction.java | 15 +++++ .../InsufficientFundsException.java | 10 +++ src/Assignment1/TransactionInterface.java | 12 ++++ src/Assignment1/WithdrawalTransaction.java | 45 ++++++++++++++ src/Assignment1/main.java | 41 +++++++++++++ src/Lecture1_adt/Transaction5.java | 18 ------ .../BankAccount.java | 21 +------ .../BaseTransaction.java | 45 ++++++-------- ...ransaction.java => DepositTrasaction.java} | 4 +- .../ReversalTransaction.java | 29 --------- .../TransactionInterface.java | 1 + .../WithdrawalTransaction.java | 61 ++++++++----------- src/Main.java | 53 +++++----------- 15 files changed, 262 insertions(+), 167 deletions(-) create mode 100644 src/Assignment1/BankAccount.java create mode 100644 src/Assignment1/BaseTransaction.java create mode 100644 src/Assignment1/DepositTransaction.java create mode 100644 src/Assignment1/InsufficientFundsException.java create mode 100644 src/Assignment1/TransactionInterface.java create mode 100644 src/Assignment1/WithdrawalTransaction.java create mode 100644 src/Assignment1/main.java delete mode 100644 src/Lecture1_adt/Transaction5.java rename src/Lecture4_interfaces_abstract_classes/{DepositTransaction.java => DepositTrasaction.java} (84%) delete mode 100644 src/Lecture4_interfaces_abstract_classes/ReversalTransaction.java diff --git a/src/Assignment1/BankAccount.java b/src/Assignment1/BankAccount.java new file mode 100644 index 0000000..c2424f4 --- /dev/null +++ b/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; + } +} diff --git a/src/Assignment1/BaseTransaction.java b/src/Assignment1/BaseTransaction.java new file mode 100644 index 0000000..e84d9a8 --- /dev/null +++ b/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; + } +} + + + + diff --git a/src/Assignment1/DepositTransaction.java b/src/Assignment1/DepositTransaction.java new file mode 100644 index 0000000..65560ab --- /dev/null +++ b/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(); + } +} diff --git a/src/Assignment1/InsufficientFundsException.java b/src/Assignment1/InsufficientFundsException.java new file mode 100644 index 0000000..18353fb --- /dev/null +++ b/src/Assignment1/InsufficientFundsException.java @@ -0,0 +1,10 @@ +package Assignment1; + +public class InsufficientFundsException extends Exception { + public InsufficientFundsException() { + public InsufficientFundsException(String message); + { + super(message); + } + } +} diff --git a/src/Assignment1/TransactionInterface.java b/src/Assignment1/TransactionInterface.java new file mode 100644 index 0000000..1110381 --- /dev/null +++ b/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(); +} \ No newline at end of file diff --git a/src/Assignment1/WithdrawalTransaction.java b/src/Assignment1/WithdrawalTransaction.java new file mode 100644 index 0000000..63e7159 --- /dev/null +++ b/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."); + } + } +} \ No newline at end of file diff --git a/src/Assignment1/main.java b/src/Assignment1/main.java new file mode 100644 index 0000000..8c2bf55 --- /dev/null +++ b/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()); + } + } +} diff --git a/src/Lecture1_adt/Transaction5.java b/src/Lecture1_adt/Transaction5.java deleted file mode 100644 index 6554eb6..0000000 --- a/src/Lecture1_adt/Transaction5.java +++ /dev/null @@ -1,18 +0,0 @@ -package Lecture1_adt; - -import java.util.Calendar; - -public class Transaction5 { - public int amount; - private Calendar date; - - - public int getAmount() { - return amount; // Because we are dealing with Value types we need not worry about what we return - } - - public Calendar getDate() { -// return date; // Because we are dealing with Reference types we need to judiciously copy what our getters return - return (Calendar) date.clone(); // Defensive copying or Judicious Copying - } -} \ No newline at end of file diff --git a/src/Lecture4_interfaces_abstract_classes/BankAccount.java b/src/Lecture4_interfaces_abstract_classes/BankAccount.java index b881a43..28d0d07 100644 --- a/src/Lecture4_interfaces_abstract_classes/BankAccount.java +++ b/src/Lecture4_interfaces_abstract_classes/BankAccount.java @@ -2,32 +2,15 @@ public class BankAccount { private double balance; - - public BankAccount(double initialBalance) { - this.balance = initialBalance; + public BankAccount(double balance) { + this.balance = balance; } - // Getter for balance public double getBalance() { return balance; } - // Setter for balance public void setBalance(double balance) { this.balance = balance; } - - // Method to print the current balance - public void printBalance() { - System.out.println("Current Balance: " + getBalance()); - } - - // Method to apply a transaction (deposit or withdrawal) - public void applyTransaction(BaseTransaction transaction) { - if (transaction instanceof WithdrawalTransaction) { - this.balance -= transaction.getAmount(); - } else if (transaction instanceof DepositTransaction) { - this.balance += transaction.getAmount(); - } - } } diff --git a/src/Lecture4_interfaces_abstract_classes/BaseTransaction.java b/src/Lecture4_interfaces_abstract_classes/BaseTransaction.java index b5e9d8d..ed81eb8 100644 --- a/src/Lecture4_interfaces_abstract_classes/BaseTransaction.java +++ b/src/Lecture4_interfaces_abstract_classes/BaseTransaction.java @@ -5,7 +5,7 @@ import java.util.Calendar; public abstract class BaseTransaction implements TransactionInterface { - private final double amount; + private final int amount; private final Calendar date; private final String transactionID; @@ -17,46 +17,35 @@ public abstract class BaseTransaction implements TransactionInterface { * Instialises the field, attributes of a transaction * Creates a object of this */ - public BaseTransaction(double amount, @NotNull Calendar date) { + public BaseTransaction(int amount, @NotNull Calendar date) { this.amount = amount; - this.date = (Calendar) date.clone();//defensive copy of date - this.transactionID = generateTransactionID(date); - } - /** - * Generates a unique transaction ID based on the date and a random value - * @param date: The transaction date to be used for ID generation - * @return A unique transaction ID string - */ - private String generateTransactionID(Calendar date) { - int uniq = (int) (Math.random() * 10000); - return date.getTime().toString() + "-" + uniq; // Combine date string and random number + this.date = (Calendar) date.clone(); + int uniq = (int) Math.random()*10000; + transactionID = date.toString()+uniq; } /** - * Gets the transaction amount - * @return The transaction amount as double + * getAmount() + * @return integer */ public double getAmount() { - return amount; + return amount; // Because we are dealing with Value types we need not worry about what we return } /** - * Gets the transaction date - * @return A defensive copy of the transaction date + * getDate() + * @return Calendar Object */ public Calendar getDate() { - return (Calendar) date.clone(); // Defensive copying to avoid external modification +// return date; // Because we are dealing with Reference types we need to judiciously copy what our getters return + return (Calendar) date.clone(); // Defensive copying or Judicious Copying } - /** - * Gets the unique transaction ID - * @return The transaction ID string - */ - public String getTransactionID() { - return transactionID; + // Method to get a unique identifier for the transaction + public String getTransactionID(){ + return transactionID; } - - // Abstract methods that must be implemented by subclasses + // Method to print a transaction receipt or details public abstract void printTransactionDetails(); public abstract void apply(BankAccount ba); -} \ No newline at end of file +} diff --git a/src/Lecture4_interfaces_abstract_classes/DepositTransaction.java b/src/Lecture4_interfaces_abstract_classes/DepositTrasaction.java similarity index 84% rename from src/Lecture4_interfaces_abstract_classes/DepositTransaction.java rename to src/Lecture4_interfaces_abstract_classes/DepositTrasaction.java index 25d62be..81afab5 100644 --- a/src/Lecture4_interfaces_abstract_classes/DepositTransaction.java +++ b/src/Lecture4_interfaces_abstract_classes/DepositTrasaction.java @@ -4,8 +4,8 @@ import java.util.Calendar; -public class DepositTransaction extends BaseTransaction { - public DepositTransaction(int amount, @NotNull Calendar date){ +public class DepositTrasaction extends BaseTransaction { + public DepositTrasaction(int amount, @NotNull Calendar date){ super(amount, date); } private boolean checkDepositAmount(int amt){ diff --git a/src/Lecture4_interfaces_abstract_classes/ReversalTransaction.java b/src/Lecture4_interfaces_abstract_classes/ReversalTransaction.java deleted file mode 100644 index 52025a2..0000000 --- a/src/Lecture4_interfaces_abstract_classes/ReversalTransaction.java +++ /dev/null @@ -1,29 +0,0 @@ -package Lecture4_interfaces_abstract_classes; - -import org.jetbrains.annotations.NotNull; -import java.util.Calendar; - -public class ReversalTransaction extends BaseTransaction { - - private boolean isReversed = true; - - // Change the constructor to accept a double amount - public ReversalTransaction(double amount, @NotNull Calendar date) { - super(amount, date); - } - - public void apply(BankAccount ba) { - double currentBalance = ba.getBalance(); - double amountToReverse = getAmount(); - ba.setBalance(currentBalance + amountToReverse); - System.out.println("Reversal of " + amountToReverse + " applied successfully."); - } - - public void printTransactionDetails() { - System.out.println("Reversal Transaction:"); - System.out.println("Amount: " + getAmount()); - System.out.println("Date: " + getDate().getTime()); - System.out.println("Transaction ID: " + getTransactionID()); - System.out.println("Reversed: " + (isReversed ? "Yes" : "No")); - } -} diff --git a/src/Lecture4_interfaces_abstract_classes/TransactionInterface.java b/src/Lecture4_interfaces_abstract_classes/TransactionInterface.java index 5902713..53cf54a 100644 --- a/src/Lecture4_interfaces_abstract_classes/TransactionInterface.java +++ b/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(); } diff --git a/src/Lecture4_interfaces_abstract_classes/WithdrawalTransaction.java b/src/Lecture4_interfaces_abstract_classes/WithdrawalTransaction.java index de62fa9..face5b6 100644 --- a/src/Lecture4_interfaces_abstract_classes/WithdrawalTransaction.java +++ b/src/Lecture4_interfaces_abstract_classes/WithdrawalTransaction.java @@ -1,52 +1,45 @@ package Lecture4_interfaces_abstract_classes; import org.jetbrains.annotations.NotNull; + import java.util.Calendar; public class WithdrawalTransaction extends BaseTransaction { - public WithdrawalTransaction(int amount, @NotNull Calendar date) { super(amount, date); } - private boolean checkWithdrawalAmount(double amt) { - return amt >= 0; - } - @Override - public void apply(BankAccount ba) { - apply(ba, "Standard Withdrawal"); // Default to "Standard Withdrawal" type - } - - public void apply(BankAccount ba, String withdrawalType) { - double currentBalance = ba.getBalance(); - - if (!checkWithdrawalAmount(getAmount())) { - System.out.println("Invalid withdrawal amount."); - return; - } - - if (currentBalance >= getAmount()) { - double newBalance = currentBalance - getAmount(); - ba.setBalance(newBalance); - System.out.println("Withdrawal of " + getAmount() + " applied successfully."); + private boolean checkDepositAmount(int amt) { + if (amt < 0) { + return false; } else { - System.out.println("Insufficient funds for withdrawal."); + return true; } } + // Method to reverse the transaction + public boolean reverse() { + return true; + } // return true if reversal was successful + + // Method to print a transaction receipt or details public void printTransactionDetails() { - System.out.println("Withdrawal Transaction:"); - System.out.println("Amount: " + getAmount()); - System.out.println("Date: " + getDate().getTime()); - System.out.println("Transaction ID: " + getTransactionID()); + System.out.println("Deposit Trasaction: " + this.toString()); } - // Reverse method to create a ReversalTransaction - public ReversalTransaction reverse(BankAccount ba) { - double currentBalance = ba.getBalance(); - ba.setBalance(currentBalance + getAmount()); - - // Create a reversal transaction with a double amount - return new ReversalTransaction(this.getAmount(), this.getDate()); + /* + Oportunity for assignment: implementing different form of withdrawal + */ + public void apply(BankAccount ba) { + double curr_balance = ba.getBalance(); + if (curr_balance > getAmount()) { + double new_balance = curr_balance - getAmount(); + ba.setBalance(new_balance); + } } -} \ No newline at end of file + + /* + Assignment 1 Q3: Write the Reverse method - a method unique to the WithdrawalTransaction Class + */ +} + diff --git a/src/Main.java b/src/Main.java index eae2fbb..584a048 100644 --- a/src/Main.java +++ b/src/Main.java @@ -1,5 +1,4 @@ import Lecture1_adt.*; // Import all classes from Lecture1_adt package to be used in this client code -import Lecture4_interfaces_abstract_classes.*; import java.util.Calendar; import java.util.GregorianCalendar; @@ -45,6 +44,7 @@ public static void testTransaction2() { Calendar d1 = new GregorianCalendar(); Lecture1_adt.Transaction2 t = new Lecture1_adt.Transaction2(1000, d1); + Lecture1_adt.Transaction2 modified_t = makeNextPayment(t); System.out.println("\n\nState of the Object T1 After Client Code Tried to Change the Amount"); @@ -70,6 +70,8 @@ public static List makeYearOfPayments (int amount) throws NullPoin List listOfTransaction3s = new ArrayList(); Calendar date = new GregorianCalendar(2024, Calendar.JANUARY, 3); + + for (int i = 0; i < 12; i++) { listOfTransaction3s.add(new Transaction3(amount, date)); date.add(Calendar.MONTH, 1); @@ -81,8 +83,11 @@ public static List makeYearOfPayments (int amount) throws NullPoin Testing Transaction3 class */ public static void testTransaction3() { + List allPaymentsIn2024 = makeYearOfPayments(1000); + for (Transaction3 t3 : allPaymentsIn2024) { + // Display all the 12 Transactions for (Transaction3 transact : allPaymentsIn2024) { System.out.println("\n\n ::::::::::::::::::::::::::::::::::::::::::::\n"); @@ -109,6 +114,7 @@ public static List makeYearOfPaymentsFinal (int amount) throws Nul List listOfTransaction4s = new ArrayList(); Calendar date = new GregorianCalendar(2024, Calendar.JANUARY, 3); + for (int i = 0; i < 12; i++) { listOfTransaction4s.add(new Transaction4(amount, date)); date.add(Calendar.MONTH, 1); @@ -120,46 +126,21 @@ public static List makeYearOfPaymentsFinal (int amount) throws Nul Testing Transaction3 class */ public static void testTransaction4() { + + /* + * Call the function to make all the Twelve transaction in a year of our business + */ + List 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()); } - } - // New method to test Withdrawal and Reversal Transactions with BankAccount - public static void testWithdrawalAndReversal() { - // Create a BankAccount with an initial balance of 5000 - BankAccount bankAccount = new BankAccount(5000); - bankAccount.printBalance(); // Initial balance - // Create and apply a standard withdrawal - Calendar d1 = new GregorianCalendar(); - WithdrawalTransaction standardWithdrawal = new WithdrawalTransaction(1000, d1); - standardWithdrawal.apply(bankAccount, "Standard Withdrawal"); - System.out.println("\nAfter Standard Withdrawal:"); - bankAccount.printBalance(); // Balance after standard withdrawal - - // Create and apply an ATM withdrawal - WithdrawalTransaction atmWithdrawal = new WithdrawalTransaction(500, d1); - atmWithdrawal.apply(bankAccount, "ATM Withdrawal"); - System.out.println("\nAfter ATM Withdrawal:"); - bankAccount.printBalance(); // Balance after ATM withdrawal - - // Create and apply an online withdrawal - WithdrawalTransaction onlineWithdrawal = new WithdrawalTransaction(200, d1); - onlineWithdrawal.apply(bankAccount, "Online Withdrawal"); - System.out.println("\nAfter Online Withdrawal:"); - bankAccount.printBalance(); // Balance after online withdrawal - - - // Create a reversal of the withdrawal transaction - ReversalTransaction reversal = standardWithdrawal.reverse(bankAccount); - - // Apply the reversal transaction to the account - bankAccount.applyTransaction(reversal); - System.out.println("\nAfter Reversal:"); - bankAccount.printBalance(); // Balance after reversal + // Please Take a look at all the 12 transaction now and compare with the outputs of the Transaction3 class } @@ -167,11 +148,9 @@ 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(); + // testTransaction1() // testTransaction2() // testTransaction3() // testTransaction4() - - testWithdrawalAndReversal(); } } \ No newline at end of file