Java OOP Banking System

[u/Lopsided-Stranger-81]

Hi guys, I made this code as practice, I'm trying to improve but don't know where to start, I'm learning Java for almost 3 months now and I'm wondering how I'm doing, can anyone give some tips?

[u/Lopsided-Stranger-81]

https://github.com/carlojaybacus14-cyber/Java-OOP-Banking-System.git
I made this repository in Github, I'm constantly changing the code

[u/d-k-Brazz → u/Lopsided-Stranger-81]

4. Another significant concept of OOP is composition

You have a Bank class
The Bank (in a very simplified universe) consists of it's cash, stored in a safe, and account records - which part of this cache belongs to which customer, and which customer owes bunk which amount of money

So we can say that a Bank is composed of an instance of BanksCashAccount and a list of Accounts
And this will be the state of your bank

class Bank {
  private bankCash BanksCashAccount;
  private List<Account> accounts;
  // other attributes like bank name, code address etc.
  
  public void deposit(String accNum, amount) {
     Account customerAccount = ... // find account by number in 'accounts' collection by accNum
     transfer(bankCash, customerAccount, amount); 
  }

  public void withdraw(String accNum, amount) {
     Account customerAccount = ... // find account by number in 'accounts' collection by accNum
     transfer(customerAccount, bankCash, amount); 
  }
  
  public void openAccount(name, type, etc.) {
    // create an instance of an appropriate account class for the type
    Account customerAccount = new SavingsAccount(name);
    accounts.add(customerAccount);
  }

  public void closeAccount(String accNum) {
     Account customerAccount = ... // find account by number in 'accounts' collection by accNum
     // validate that customer account is eligible for closing
     accounts.remove(customerAccount); 
  }

  public BigDecimal balance() {
    // sum up all the amounts of all the accounts and bankCashAccount
  }
}

You may instantiate multiple banks and make different actions on them, and these banks will hold different states

[u/Lopsided-Stranger-81 → u/d-k-Brazz]

Got it, I got stuck thinking with each of their relationship from class to class using extends, but I got a hang of them, all I need to know is how banking really works. I will use this as resource, thanks for the feedback!

[u/d-k-Brazz → u/Lopsided-Stranger-81]

Took a look at your project and it looks like you still not quite understand OOP principles and what they can do for you

1. Encapsulation
   This means that any object of the class has it's state which is hidden inside, and the logic of changing the state is hidden inside the class, so other actors are only allowed to impact this state by calling class methods. And the class is always in control to prevent actions which may turn the object into an inconsistent state.
   Example - class Bank, the client can modify state of the bank by calling following methods:

String myAccNumber = acmeBank.openAccount(name, type)  
// bank will create an instance of Account inside
// but we don't care of it, as it is hidden from us (encapsulated)

acmeBank.deposit(myAccountNumber, 1000)  
// OK, bank state changed, nothing violated

acmeBank.transfer(myAccountNumber, anotherGuyAccount, 300)  
// OK, client is allowed to transfer this amount from his account

acmeBank.transfer(myAccountNumber, anotherGuyAccount, 1500)  
// ERROR, client does not have 1500 on the account. 
// This leads to an inconsistent state and
// should be prevented by Bank class by throwing an exception

acmeBank.withdraw(myAccountNumber, 2000)  
// ERROR, client can not withdraw this sum. 
Inconsistent state, throw an exception

acmeBank.closeAccount(myAccountNumber)  
// ERROR, client must first withdraw or transfer 
// the rest of funds before closing account

The class controls it's state and prevents any inconsistency

In Java you have private fields for the state and public methods for any modifications.

[u/d-k-Brazz → u/Lopsided-Stranger-81]

2. Inheritance

This means you may build hierarchy of classes - higher and lower level
All lower level classes will inherit all public behavior of higher level classes

Example

abstract class Account {
  private String name;
  private String number;
  private BigDecimal amount;
  
  // withdraw amount from the account
  public abstract void debit(BigDecimal sum);
  // add amount to the account
  public abstract void credit(BigDecimal sum);
}  

class PassiveAccount extends Account {
  // forbids crediting below 0
}

class ActiveAccount extends Account {
  // forbids debiting above 0
}

class SavingsAccount extends PassiveAccount {
  // customer's savings
  // may have attributes like interest rate, 
  // or limitations like possibility of partial
  // withdrawal before the end of savings contract
}

class CheckingAccount extends PassiveAccount {
  // allows any transfers within the available amount
}

class BanksCashAccount extends ActiveAccount {
  // cash funds in possession of the bank
  // transferring from this account to another 
  // means someone has brought some cash to the bank
  // negative value reflects amount of cash money in the bank
}

class LoanAccount extends ActiveAccount {
  // may have attributes like interest rate, 
  // credit limit etc.
}

This will allow you to build common logic for all account:

public void transfer(Account accFrom, Account accTo) {
  // the logic inside does not care of kinds of accounts
  // each account limitations and constraints are encapsulated 
  // inside the according Account ancestor class
  // 
  // this is method of a Bank class and from bank's perspective
  // each transfer should be consistent
  // this means that if you successfully debited accFrom, 
  // but crediting accTo has failed, you have return money to accFrom back
}

Using this common method you can deposit cash money to an account, transfer money to a counterparty, withdraw a part of a load etc.

[u/d-k-Brazz → u/Lopsided-Stranger-81]

3. Polymorphism
Any object may be treated as different class instances an in different contexts
This means that the object of class BankTransaction may be treated as Comparable when you put a list of BankTransactions into a sorting algorithm - sorting is generic and doesn't aware of what class it is, it just wants from you to implement comparing specification according to Comparable interface

At the same time BankTransaction may implement other specifications needed for other common algorithms, like Serializable which is required for json/xml serialization

[u/d-k-Brazz]

Any OOP starts from modeling the domain

In banks you have multiple accounts - thousands of them.
Each account has its number/name and an amount value (use Bigdecimal or store amount in cents as Integer for precise calculations)

All transactions in a bank are moving funds from one account to another

Deposit and withdraw operations involve cash money, for these operations you create a “cashier” account, which is supposed to be active - it’s amount is usually negative, and the value reflects amount of cash money the bank possesses at the moment

So as a bank you may have a number of instances of Account:

123 : Alice (passive) - $0
456: Bob (passive) - $0
098: Cashier (active) - $0
Balance (sum of all amounts) - $0

Bob deposits:
Bank.move(098, 123, $1000.00)
Cash -$1000.00
Bob +$1000.00
Balance - 0

Bob sends Alice $470
Bank.move(123, 456, $470.00)
Cash -$1000.00
Bob +$530.00
Alice +$470.00
Balance - 0

Alice withdraws $120
Bank.move(456, 098, $120.00)
Cash -$880.00
Bob +$530.00
Alice +$350.00
Balance - 0

[u/d-k-Brazz → u/d-k-Brazz]

So you need an Account class

Attributes - number, name, type(active/passive), amount

You need a class for handling transactions, receives accounts “from” and “to” and an amount

Result of moving money should be a transaction object - with id, date, purpose, accounts and amount - you need transaction history, aren’t you?

Additionally think of making draft transactions, where accounts aren’t affected until you commit the transaction, but amount should be reserved until you cancel it

[u/Lopsided-Stranger-81 → u/d-k-Brazz]

Thanks I'll take note of it

[u/d-k-Brazz]

Never use float/double for financial operations

Use Bigdecimal instead

[u/abcd98712345]

not specific to java but conceptually look at martin fowlers money pattern and double-entry ledger accounting systems as far as modeling this domain in a better way

[u/RSSeiken]

Can you push it to a github repo? Might be a good moment to learn git too, I like to use git bash, then I don't have to depend on different IDE's.

It's a bit difficult using only screenshots.

[u/Lopsided-Stranger-81 → u/RSSeiken]

alright i'll try that, tho i still don't know how to use github.

[u/RSSeiken → u/Lopsided-Stranger-81]

It's a short tutorial, don't worry too much about that.

[u/Lopsided-Stranger-81 → u/RSSeiken]

okay ill create a repository to start with it then.

[u/oppertunity_1]

Can I get this project to practice ?

[u/Lopsided-Stranger-81 → u/oppertunity_1]

Yeah sure, it's currently not working right now tho

[u/Reasonable_Page2001]

Is that oop means object oriented programming

[u/Lopsided-Stranger-81 → u/Reasonable_Page2001]

Yes

[u/[deleted]]

same dude, 3 months learning Java and now making a Bank Management System.
thanks for posting in the mid of my mental breakdown.

[u/WearyHead6364]

Good job