Demo: rewriting a procedural bank as objects

Written Explanation

Step 1: the procedural version

The description: "The bank has accounts. Each account has an owner, a number, and a balance. Customers deposit and withdraw money, and an account can be shown."

Here is the procedural program, with the money in cents:

public class BankProc {
    static void deposit(int[] balances, int i, int amount) {
        balances[i] += amount;
    }
    static boolean withdraw(int[] balances, int i, int amount) {
        if (amount > balances[i]) {
            return false;
        }
        balances[i] -= amount;
        return true;
    }
    static void show(String[] owners, int[] numbers, int[] balances, int i) {
        System.out.println(numbers[i] + " " + owners[i] + ": " + balances[i]);
    }
    public static void main(String[] args) {
        String[] owners = {"Ana", "Omar"};
        int[] numbers = {1001, 1002};
        int[] balances = {10000, 5000};
        deposit(balances, 0, 2500);
        boolean ok = withdraw(balances, 1, 9000);
        System.out.println("Withdrawal accepted: " + ok);
        show(owners, numbers, balances, 0);
        show(owners, numbers, balances, 1);
    }
}

Output:

Withdrawal accepted: false
1001 Ana: 12500
1002 Omar: 5000

Ana's deposit worked. Omar's withdrawal of 90.00 was refused because he only has 50.00. Notice how every call passes arrays and an index, and show needs three arrays.

Step 2: nouns and verbs

From the description: nouns are bank, accounts, owner, number, balance, customers, money. Verbs are deposit, withdraw, show.

Verbs deposit, withdraw, and show all change or read an account's own balance, so they belong to Account. One class results, and that is a fine outcome. Rejecting Bank and Customer here is a decision for this text only.

Step 3: create the Account class

Three arrays become three fields in one class:

class Account {
    String owner;
    int number;
    int balance;
}

Step 4: move the behavior in

Each loose method becomes a method of Account. The array and the index vanish: the method now works on this object's balance.

class Account {
    String owner;
    int number;
    int balance;
    void deposit(int amount) {
        balance += amount;
    }
    boolean withdraw(int amount) {
        if (amount > balance) {
            return false;
        }
        balance -= amount;
        return true;
    }
    void show() {
        System.out.println(number + " " + owner + ": " + balance);
    }
}

The rule "no withdrawal above the balance" is now inside withdraw, next to the balance it protects.

Step 5: the objects in main

public class BankObj {
    public static void main(String[] args) {
        Account ana = new Account();
        ana.owner = "Ana";
        ana.number = 1001;
        ana.balance = 10000;
        Account omar = new Account();
        omar.owner = "Omar";
        omar.number = 1002;
        omar.balance = 5000;
        ana.deposit(2500);
        boolean ok = omar.withdraw(9000);
        System.out.println("Withdrawal accepted: " + ok);
        ana.show();
        omar.show();
    }
}

Output (compiled together with the Account class):

Withdrawal accepted: false
1001 Ana: 12500
1002 Omar: 5000

Identical output, different structure. The calls ana.deposit(2500) and ana.show() say what they mean: no arrays, no index.

One honest observation: this main is not shorter than before, because we still fill in each field by hand (about 25 lines for the procedural file against about 35 for the whole object file). The setup lines will shrink in the next module, where constructors let you create an account and set its values in a single line. The calls that use the accounts are already shorter and clearer.

Step 6: the planned mistake

Here is a tempting half-measure. You create the Account class but leave deposit outside, as a static method that takes the account as a parameter:

public class BankMistake {
    static void deposit(Account a, int amount) {
        a.balance += amount;
    }
    public static void main(String[] args) {
        Account ana = new Account();
        ana.balance = 10000;
        deposit(ana, 2500);
        ana.balance = -1;              // still nothing guards the data
        System.out.println(ana.balance);
    }
}
class Account {
    String owner;
    int number;
    int balance;
}

It compiles and runs, and prints -1. The data is now grouped in one object, which is an improvement, but the behavior is separated from the data it acts on. deposit is a loose method any file can have a copy of; the account does not know how to deposit; and because rules live elsewhere, a different part of the program can write -1 freely. This is the module's common mistake: a class that is only a bag of fields, with all logic in outside functions, gives you little more than the parallel arrays did.

The fix is Step 4: move deposit inside the class so the object manages its own balance. (Making fields impossible to write from outside is a topic for a later module; at this point moving behavior in is the first step.)

Step 7: adding currency

Now the change that hurt in lesson 1. Add one field to the class and print it in show:

    String currency = "SAR";
    // in show():
    System.out.println(number + " " + owner + ": " + balance + " " + currency);

Compiling and running the object version with exactly these two edits gives:

Withdrawal accepted: false
1001 Ana: 12500 SAR
1002 Omar: 5000 SAR

Two lines changed. In the procedural version, a new array, new parameters on show, and updated calls were required. The currency = "SAR" assignment on the field is a default value that every new account starts with; the next module explains it properly. (SAR is used here only as an example currency code.)