CISC 3115 — Lecture 3 — Classes Part II

CISC 3115
Modern Programming Techniques
Lecture 1
Motivating Classes

00 — Just a Simple App

What does this app do?

import java.util.*;

public class App {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);

		int id = readId(in);
		String tag = readTag(in);
		int value = readValue(in);

		System.out.println("--- After reading in the values");
		printState(id, tag, value);
		System.out.println();

		System.out.println("--- Performing putIn 50");
		value = putIn(value, 50);
		printState(id, tag, value);

		System.out.println("--- Performing takeOut 20");
		value = takeOut(value, 20);
		printState(id, tag, value);
	}

	// ---------------- Input ----------------

	static int readId(Scanner in) {
		System.out.print("Enter id: ");
		return in.nextInt();
	}

	static String readTag(Scanner in) {
		System.out.print("Enter tag: ");
		return in.next();
	}

	static int readValue(Scanner in) {
		System.out.print("Enter value: ");
		return in.nextInt();
	}

	// ---------------- Operations ----------------

	static int putIn(int value, int amount) {return value + amount;}

	static int takeOut(int value, int amount) {return value - amount;}

	// ---------------- Output ----------------

	static void printState(int id, String tag, int value) {
		System.out.println("STATE");
		System.out.println("-----");
		System.out.println("id  = " + id);
		System.out.println("tag  = " + tag);
		System.out.println("value = " + value);
	}
}

The operation methods, putIn, and takeOut, cannot modify the balance in place, because they are passed by-value; rather they must return the new value, which is then assigned (by main — the caller) to balance.
This app introduces the basic structure we will use for the apps presented this lecture:
- A sequence of readxxx methods that read in the relevant values
- Methods that operate on these values (putIn and takeOut in this instance)
- A method to print out those values.
  - The state is the collection of the relevant values
id, tag, and value must be passed to printState as they are used by that method

10010
Weiss
100

Enter id: 10010
Enter tag: Weiss
Enter value: 100
--- After reading in the values
STATE
-----
id  = 10010
tag  = Weiss
value = 100

--- Performing putIn 50
STATE
-----
id  = 10010
tag  = Weiss
value = 150
--- Performing takeOut 20
STATE
-----
id  = 10010
tag  = Weiss
value = 130

Enter id: Enter tag: Enter value: --- After reading in the values
STATE
-----
id  = 10010
tag  = Weiss
value = 100

--- Performing putIn 50
STATE
-----
id  = 10010
tag  = Weiss
value = 150
--- Performing takeOut 20
STATE
-----
id  = 10010
tag  = Weiss
value = 130

stdout presents the exact output produced by the System.out.println's of the program … including the prompts

The interactive session presents what you see at the terminal; this includes the keyboard input which is mirrored (together with the nmewlines generated by the carriage returns types by the user).

The only hints are the names of the methods … this is clearly some sort of program for keep track of some sort of quantity that can be increased and/or decreased.
The names of the other variables id, tag, value, also convey possible interpretations, but on a much more general scale.
Notice these 'hints' are provided by the programmer (in the form of choice of names); it is NOT enforced by the language.

01 — `BankAccount`: An App with Application Semantics

Now consider the following app:

import java.util.*;

public class BankAccountApp {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        int accountNumber = readAccountNumber(in);
        String owner = readOwner(in);
        int balance = readBalance(in);   // units interpreted as cents

        System.out.println("After creating account");
        printAccount(accountNumber, owner, balance);

        System.out.println("Preforming deposit 50"); 
        balance = deposit(balance, 5000);      // $50.00
        printAccount(accountNumber, owner, balance);

        System.out.println("Preforming deposit withdrawal 2000"); 
        balance = withdraw(balance, 2000);     // $20.00
        printAccount(accountNumber, owner, balance);
    }

    // ---------------- Input ----------------

    static int readAccountNumber(Scanner in) {
        System.out.print("Enter account number: ");
        return in.nextInt();
    }

    static String readOwner(Scanner in) {
        System.out.print("Enter owner name: ");
        return in.next();
    }

    static int readBalance(Scanner in) {
        System.out.print("Enter starting balance (cents): ");
        return in.nextInt();
    }

    // ---------------- Operations ----------------

    static int deposit(int balance, int amount) {
        return balance + amount;
    }

    static int withdraw(int balance, int amount) {
        return balance - amount;
    }

    // ---------------- Output ----------------

    static void printAccount(int accountNumber, String owner, int balance) {
        System.out.println("ACCOUNT STATE");
        System.out.println("-------------");
        System.out.println("Account #: " + accountNumber);
        System.out.println("Owner: " + owner);
        System.out.println("Balance: " + balance + " cents");
    }
}

The specific application is now clear
- This is still, however, purely a consequence of the programmer employing semantically meaningful names for the class, methods, and variables
  - In particular, the language (i.e., the compiler) does not (and really cannot) enforce this
- There's nothing explicitly indicating this as a bank account; you have to infer it from the attributes and methods
Some questions to be addressed:
- What are we dealing with, and how do you know?
- What are the attributes (i.e., characteristics) of the thing we are dealing with and how do you know?
  - In particular, how do you know there aren't other attributes?
- What are the actions/operations thtat can be performed on the thing we are dealing with and how do you know?
What about withdrawing more than the balance (or having negative balances altogether)?

02 — Adding Additional Attributes

Suppose we decide to add the following attributes:

Status (ACTIVE/CLOSED)
Date account was opened

import java.util.*;

public class BankAccountApp {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        int accountNumber = readAccountNumber(in);
        String owner = readOwner(in);
        int balance = readBalance(in);        // cents
        String status = readStatus(in);
        String openedDate = readOpenedDate(in);

        System.out.println("--- After creating account");
        printAccount(accountNumber, owner, balance, status, openedDate);
        System.out.println("Performing deport 5000");

        System.out.println("--- Performing deposit 5000");
        balance = deposit(balance, 5000);
        printAccount(accountNumber, owner, balance, status, openedDate);

        System.out.println("--- Performing  withdraw 2000");
        balance = withdraw(balance, 2000);
        printAccount(accountNumber, owner, balance, status, openedDate);
    }

    // ---------------- Input ----------------

    static int readAccountNumber(Scanner in) {
        System.out.print("Enter account number: ");
        return in.nextInt();
    }

    static String readOwner(Scanner in) {
        System.out.print("Enter owner name: ");
        return in.next();
    }

    static int readBalance(Scanner in) {
        System.out.print("Enter starting balance (cents): ");
        return in.nextInt();
    }

    static String readStatus(Scanner in) {
        System.out.print("Enter status: ");
        return in.next();
    }

    static String readOpenedDate(Scanner in) {
        System.out.print("Enter opened date: ");
        return in.next();
    }

    // ---------------- Operations ----------------

    static int deposit(int balance, int amount) {return balance + amount;}

    static int withdraw(int balance, int amount) {return balance - amount;}

    // ---------------- Output ----------------

    static void printAccount(int accountNumber, String owner, int balance, String status, String openedDate) {
        System.out.println("ACCOUNT STATE");
        System.out.println("-------------");
        System.out.println("Account #: " + accountNumber);
        System.out.println("Owner: " + owner);
        System.out.println("Balance: " + balance + " cents");
        System.out.println("Status: " + status);
        System.out.println("Opened: " + openedDate);
    }
}

We have to add additional read… methods.
We also need at modify the signature (and logic) of the printAccount method to include those attributes
Any new operations introduced as a result of the introduction of the new attributes must be added as well
- None in this simple example, but could have things like applying giving a cash bonus to accounts active a year of more
It may also be necessary (not in this case) to add new operation methods and/or modify existing methods to reflect the presence of new attributes
- Notice that we are not using status in our logic … shouldn't we
Clearly, something like this will be done each time we add (or remove) an attribute.
- Again, how do we know these are the only attributes for the bank account

03 — What About Rules for Bank Account Operations?

Suppose we wanted withdraw to act more realistically; i.e., you can only withdraw if the account is ACTIVE

static int withdraw(int balance,
                    int amount,
                    String status) {

    if (!status.equals("ACTIVE")) {
        System.out.println("Withdrawal denied: account not active");
        return balance;
    }

    return balance - amount;
}

…
		System.out.println("--- Performing a deposit of 5000");
        balance = deposit(balance, 5000);
        printAccount(accountNumber, owner, balance, status, openedDate);
        System.out.println();

		System.out.println("--- Performing a withdrawal of 2000");
        balance = withdraw(balance, 2000, status);
        printAccount(accountNumber, owner, balance, status, openedDate);
…

Some things to think about:

The caller now has to pass in the status as well as the balance and amount … how are they expected to know that?
Shouldn't we have this check for deposit as well (and any other operation that requires an active account)?
There are other rules; for example, we probably don't want to start off with a negative balance; we may also not wish to allow a withdrawal larger than the balance
Even with these rules added to the operations, what prevents the user (i.e., main) from bypassing all that logic by nit calling the operation method and doing the logic on their own?

04 — Detour: Multiple Accounts … Parallel Arrays

Now suppose we want a number of bank accounts

First we need each attribute to become an array:

int [] accountNumbers;
String [] owners;
int [] balances;
String [] statuses;
String [] openedDates;

The identity of a bank account is now its index in the array (before it was the values of the single set of attribute variables).
In other words, a bank account is identified by its position, i.e., index in the array
- There's no semantic association of the account identity (i.e., its position) with the account itself

What if we inset a new account at the front (or anywhere in the middle)?
What if we delete an element?
What if we sort the arrays?

Sorting Parallel Arrays

Sorting poses a particular challenge when dealing with parallel arrays.

You have to make sure you swap all the arrays properly or you corrupt the whole thing

swap(accountNumbers, i, j);
swap(owners, i, j);
swap(balances, i, j);
swap(statuses, i, j);
swap(openedDates, i, j);

This exposes the position is identity issue

Here is an app operating on a set of parallel arrays representing 'bank accounts'.

import java.util.*;
import java.io.*;

public class BankAccountApp {

    public static void main(String[] args) throws Exception {
        Scanner in = new Scanner(new File("accounts.text"));

		final int CAPACITY = 100;

        int [] accountNumbers = new int[CAPACITY];
        String [] owners = new String[CAPACITY];
        int [] balances = new int[CAPACITY];
        String [] statuses = new String[CAPACITY];
        String [] openedDates = new String[CAPACITY];

		int size = 0;
		while (in.hasNextInt()) {
			accountNumbers[size] = readAccountNumber(in);
			owners[size] = readOwner(in);
			balances[size] = readBalance(in);        // cents
			statuses[size] = readstatuses(in);
			openedDates[size] = readOpenedDate(in);
			size++;
		}

		System.out.println("-- After reading in and creating the accounts");
        printAccounts(accountNumbers, owners, balances, statuses, openedDates, size);

		System.out.println("--- Performing a deposit of 5000 on account at position 1");
        balances[1] = deposit(balances[1], 5000);
        printAccounts(accountNumbers, owners, balances, statuses, openedDates, size);

		System.out.println("-- Sorting by owner");
        sort(accountNumbers, owners, balances, statuses, openedDates, size);
        printAccounts(accountNumbers, owners, balances, statuses, openedDates, size);

    }

    // ---------------- Input ----------------

    static int readAccountNumber(Scanner in) {
        return in.nextInt();
    }

    static String readOwner(Scanner in) {
        return in.next();
    }

    static int readBalance(Scanner in) {
        return in.nextInt();
    }

    static String readstatuses(Scanner in) {
        return in.next();
    }

    static String readOpenedDate(Scanner in) {
        return in.next();
    }

    // ---------------- Operations ----------------

    static int deposit(int balances, int amount) {return balances + amount;}

	static int withdraw(int balance, int amount, String statuses) {
		if (!statuses.equals("ACTIVE")) {
			System.out.println("Withdrawal denied: account not active");
			return balance;
		}
		return balance - amount;
	}

    // ---------------- Output ----------------

    static void printAccounts(int [] accountNumbers, String [] owners, int [] balances, String [] statuses, String [] openedDates, int size) {
        System.out.println("\nACCOUNTS");
        System.out.println("-------------");
		for (int i = 0; i < size; i++) { 
			printAccount(accountNumbers[i], owners[i], balances[i], statuses[i], openedDates[i]);
			System.out.println();
		}
	} 

    static void printAccount(int accountNumber, String owner, int balance, String status, String openedDate) {
        System.out.println("Account #: " + accountNumber);
        System.out.println("Owner: " + owner);
        System.out.println("Balance: " + balance + " cents");
        System.out.println("status: " + status);
        System.out.println("Opened: " + openedDate);
    }

    static void sort(int [] accountNumbers, String [] owners, int [] balances, String [] statuses, String [] openedDates, int size) {
		boolean swapped = true;
		for (int last = size-1; size > 0 && swapped; size --) {
			swapped = false;
			for (int i = 0; i < last; i++)
				if (owners[i].compareTo(owners[i+1]) > 0) {
					swap(accountNumbers, i, i+1);
					swap(owners, i, i+1);
					swap(balances, i, i+1);
					swap(statuses, i, i+1);
					swap(openedDates, i, i+1);
					swapped = true;
				}
		}
	}

	static void swap(int [] arr, int idx1, int idx2) {
		int t = arr[idx1];
		arr[idx1] = arr[idx2];
		arr[idx2] = t;
	}

	static void swap(String [] arr, int idx1, int idx2) {
		String t = arr[idx1];
		arr[idx1] = arr[idx2];
		arr[idx2] = t;
	}
}

ALl the parallel arrays must be passed to the sort.
Note the parallel swapping that must be performed
Only one swap method needs to be defined; one per data type (i.e., not one per attribute)

10010
Weiss
10000
ACTIVE
01/25/2026

10020
Arnow
20000
ACTIVE
12/21/2025

10030
Sokol
0
CLOSED
11/19/2025

stdout
-- After reading in and creating the accounts

ACCOUNTS
-------------
Account #: 10010
Owner: Weiss
Balance: 10000 cents
status: ACTIVE
Opened: 01/25/2026

Account #: 10020
Owner: Arnow
Balance: 20000 cents
status: ACTIVE
Opened: 12/21/2025

Account #: 10030
Owner: Sokol
Balance: 0 cents
status: CLOSED
Opened: 11/19/2025

--- Performing a deposit of 5000 on account at position 1

ACCOUNTS
-------------
Account #: 10010
Owner: Weiss
Balance: 10000 cents
status: ACTIVE
Opened: 01/25/2026

Account #: 10020
Owner: Arnow
Balance: 25000 cents
status: ACTIVE
Opened: 12/21/2025

Account #: 10030
Owner: Sokol
Balance: 0 cents
status: CLOSED
Opened: 11/19/2025

-- Sorting by owner

ACCOUNTS
-------------
Account #: 10020
Owner: Arnow
Balance: 25000 cents
status: ACTIVE
Opened: 12/21/2025

Account #: 10030
Owner: Sokol
Balance: 0 cents
status: CLOSED
Opened: 11/19/2025

Account #: 10010
Owner: Weiss
Balance: 10000 cents
status: ACTIVE
Opened: 01/25/2026

05 — A First Step Towards a Solution … Isolating the Bank Account Methods

Let's isolate those methods that work on bank accounts and place them in their own file (BankAccountOps.java):

public class BankAccountOps {
    static int deposit(int balance, int amount) {
        return balance + amount;
    }

    static int withdraw(int balance, int amount, String status) {
        if (status.equals("CLOSED")) {
            System.out.println("Withdrawal denied: account closed");
            return balance;
        }
        return balance - amount;
    }

    static void printAccount(int accountNumber,
                             String owner,
                             int balance,
                             String status,
                             String openedDate) {

        System.out.println("ACCOUNT STATE");
        System.out.println("-------------");
        System.out.println("Account #: " + accountNumber);
        System.out.println("Owner:     " + owner);
        System.out.println("Balance:   " + balance + " cents");
        System.out.println("Status:    " + status);
        System.out.println("Opened:    " + openedDate);
    }
}

Here is the updated app:

import java.util.Scanner;

public class BankAccountApp {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        int accountNumber = readAccountNumber(in);
        String owner      = readOwner(in);
        int balance       = readBalance(in);
        String status     = readStatus(in);
        String openedDate = readOpenedDate(in);

        balance = BankAccountOps.deposit(balance, 5000);
        balance = BankAccountOps.withdraw(balance, 2000, status);

        BankAccountOps.printAccount(accountNumber,
                                    owner,
                                    balance,
                                    status,
                                    openedDate);
    }

    // input helpers unchanged
    static int readAccountNumber(Scanner in) {return in.nextInt();}
    static String readOwner(Scanner in) {in.nextLine(); return in.nextLine();}
    static int readBalance(Scanner in) {return in.nextInt();}
    static String readStatus(Scanner in) {in.nextLine(); return in.nextLine();}
    static String readOpenedDate(Scanner in) { return in.nextLine();}
}

The app must now include the name of the class (BankAccountOps) that contains the method when invoking it; this is similar to Math.sqrt.
We haven't really accomplished much yet; other than possibly improving the organization (and thus readability) of our code.
Note the read methods have not been moved; this is a somewhat subtle point, but they don't really operate on a bank account as such
- You may very well disagree, and you wouldn't be wrong; we'll discuss this later. In any event, at this point, this is not a matter of functionality or right/wrong; merely organization.

06 — The Next Step … Packaging the Attributes

public class BankAccountData {
    public int accountNumber;
    public String owner;
    public int balance;        // cents
    public String status;      // "ACTIVE" or "CLOSED"
    public String openedDate;  // free-form for now
}

Note this class is the data-analog of the BankAccountOps class; it contains the attributes packaged as a single (class) entity.

public class BankAccountOps {
    public static void deposit(BankAccountData account, int amount) {
        account.balance += amount;
    }

    public static void withdraw(BankAccountData account, int amount) {
        if (account.status.equals("CLOSED")) {
            System.out.println("Withdrawal denied: account is CLOSED");
            return;
        }
        account.balance -= amount;
    }

    public static void printAccount(BankAccountData account) {
        System.out.println("ACCOUNT STATE");
        System.out.println("-------------");
        System.out.println("Account #: " + account.accountNumber);
        System.out.println("Owner:     " + account.owner);
        System.out.println("Balance:   " + account.balance + " cents");
        System.out.println("Status:    " + account.status);
        System.out.println("Opened:    " + account.openedDate);
    }
}

The ops class now operates on (and accepts as a parameter) a BankAccountData entity.
The attributes are now contained in an object accessed by a reference variable (account in our example).
- Since it is the reference variable, and not the balance, that is sent, by-value, to the method, changes made to balance in the method persist after returning to the caller. As a result we can perform the deposit/withdrawal modification to balance in place, rather than returning the new value as the method return value and assigning it into balance in the caller.



import java.util.Scanner;

public class BankAccountApp {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        BankAccountData account = new BankAccountData();

        account.accountNumber = readAccountNumber(in);
        account.owner         = readOwner(in);
        account.balance       = readBalance(in);
        account.status        = readStatus(in);
        account.openedDate    = readOpenedDate(in);

        BankAccountOps.deposit(account, 5000);
        BankAccountOps.withdraw(account, 2000);

        BankAccountOps.printAccount(account);
    }

    // ----- Input helpers -----

    static int readAccountNumber(Scanner in) {
        System.out.print("Enter account number: ");
        return in.nextInt();
    }

    static String readOwner(Scanner in) {
        System.out.print("Enter owner name: ");
        in.nextLine(); // consume newline
        return in.nextLine();
    }

    static int readBalance(Scanner in) {
        System.out.print("Enter starting balance (cents): ");
        return in.nextInt();
    }

    static String readStatus(Scanner in) {
        System.out.print("Enter status (ACTIVE/CLOSED): ");
        in.nextLine(); // consume newline
        return in.nextLine();
    }

    static String readOpenedDate(Scanner in) {
        System.out.print("Enter opened date: ");
        return in.nextLine();
    }
}




	The app is still fiddling around with the account data and passing it to the ops methods.
	
Still no rule enforcement; the programmer can manipulate the balance  independently of invoking the methods



07 — Merge Ops and Attributes

class BankAccount {
    public static void deposit(BankAccount account, int amount) {
        account.balance += amount;
    }

    public static void withdraw(BankAccount account, int amount) {
        if (account.status.equals("CLOSED")) {
            System.out.println("Withdrawal denied: account is CLOSED");
            return;
        }
        account.balance -= amount;
    }

    public static void printAccount(BankAccount account) {
        System.out.println("ACCOUNT STATE");
        System.out.println("-------------");
        System.out.println("Account #: " + account.accountNumber);
        System.out.println("Owner: " + account.owner);
        System.out.println("Balance: " + account.balance + " cents");
        System.out.println("Status: " + account.status);
        System.out.println("Opened: " + account.openedDate);
    }

    int accountNumber;
    String owner;
    int balance;
    String status;
    String openedDate;
}




	We've merged the data and ops into a single class; it makes sense now to simply call it a BankAccount



import java.util.Scanner;

public class BankAccountApp {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        BankAccount account = new BankAccount();

        account.accountNumber = readAccountNumber(in);
        account.owner = readOwner(in);
        account.balance = readBalance(in);
        account.status = readStatus(in);
        account.openedDate = readOpenedDate(in);

        BankAccount.deposit(account, 5000);
        BankAccount.withdraw(account, 2000);

        BankAccount.printAccount(account);
    }

    // ----- Input helpers -----

    static int readAccountNumber(Scanner in) {
        System.out.print("Enter account number: ");
        return in.nextInt();
    }

    static String readOwner(Scanner in) {
        System.out.print("Enter owner name: ");
        return in.next();
    }

    static int readBalance(Scanner in) {
        System.out.print("Enter starting balance (cents): ");
        return in.nextInt();
    }

    static String readStatus(Scanner in) {
        System.out.print("Enter status (ACTIVE/CLOSED): ");
        return in.next();
    }

    static String readOpenedDate(Scanner in) {
        System.out.print("Enter opened date: ");
        return in.nextLine();
    }
}




	Other than the class name change, nothing has changed



08 — Detour: Arrays

Before we go further we're going to examine the effect of the previous step on apps using an array of accounts.

import java.util.*;
import java.io.*;

public class BankAccountApp {

	public static void main(String[] args) throws Exception {
		Scanner in = new Scanner(new File("accounts.text"));

		final int CAPACITY = 100;

		BankAccount [] accounts = new BankAccount[CAPACITY];

		int size = 0;
		while (in.hasNextInt()) {
			accounts[size] = new BankAccount();
			readAccount(in, accounts[size]);
			size++;
		}

		System.out.println("-- After reading in and creating the accounts");
		printAccounts(accounts, size);

		System.out.println("--- Performing a deposit of 5000 on account at position 1");
		BankAccount.deposit(accounts[1], 5000);
		printAccounts(accounts, size);

		System.out.println("-- Sorting by owner");
		sort(accounts, size);
		printAccounts(accounts, size);
	}

	// ---------------- Input ----------------

	static void readAccount(Scanner in, BankAccount account) {
		account.accountNumber = readAccountNumber(in);
		account.owner = readOwner(in);
		account.balance = readBalance(in);		  // cents
		account.status = readStatus(in);
		account.openedDate = readOpenedDate(in);
	}

	static int readAccountNumber(Scanner in) {return in.nextInt();}
	static String readOwner(Scanner in) {return in.next();}
	static int readBalance(Scanner in) {return in.nextInt();}
	static String readStatus(Scanner in) {return in.next();}
	static String readOpenedDate(Scanner in) {return in.next();}

	// ---------------- Output ----------------

	static void printAccounts(BankAccount [] accounts, int size) {
		System.out.println("ACCOUNTS");
		System.out.println("-------------");
		for (int i = 0; i < size; i++) { 
			BankAccount.printAccount(accounts[i]);
			System.out.println();
		}
	} 

	// ---------------- Sort ----------------
	
	static void sort(BankAccount [] accounts, int size) {
		boolean swapped = true;
		for (int last = size-1; size < 0 && swapped; size --) {
			swapped = false;
			for (int i = 0; i < last; i++)
				if (accounts[i].owner.compareTo(accounts[i+1].owner) > 0) {
					swap(accounts, i, i+1);
					swapped = true;
				}
		}
	}

	static void swap(BankAccount [] accounts, int idx1, int idx2) {
		BankAccount t = accounts[idx1];
		accounts[idx1] = accounts[idx2];
		accounts[idx2] = t;
	}
}




	The BankAccount class is the same as before
	
The code BankAccount [] accounts = new BankAccount[CAPACITY];
		creates the array; however the individual elements are not created by this; that is done by the 
		code accounts[size] = new BankAccount();
	
The other big changes are in the methods manipulating the arrays:
		
			printAccounts now calls printAccount with the 
				i'th bank account (rather than the i'th elements of the parallel arrays).
			
The swap method now swaps the i'th BankAccount
				element, rather than multiple parallel arrays.
		
	
Note we've moved away from the notion of the position being the identity of the bank account;
		we now have a BankAccount entity.



09 — Making Operations Account-Specific

Now comes the big change: 

	up until now the BankAccount operations accepted a BankAccount parameter representing the account to be manipulated. 
	
We are going to turn the method invocation 'inside out'. 
		
			Instead of invoking an operation and explicitly passing it a bank account to work on, we will invoke 
					the operation through a bank account; i.e., BankAccount.deposit(account, amount) becomes account.deposit(amount). 
			
The account is no longer an argument to the operation; it is the receiver of the operation, i.e., we will invoke 
				the operation on a bank account rather than giving the bank account to the operation.
		


import java.util.*;
import java.util.Scanner;

public class BankAccountApp {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        BankAccount account = new BankAccount();

        account.accountNumber = readAccountNumber(in);
        account.owner = readOwner(in);
        account.balance = readBalance(in);
        account.status = readStatus(in);
        account.openedDate = readOpenedDate(in);

        account.deposit(5000);
        account.withdraw(2000);

        account.print();
    }

    // ----- Input helpers -----

    static int readAccountNumber(Scanner in) {
        System.out.print("Enter account number: ");
        return in.nextInt();
    }

    static String readOwner(Scanner in) {
        System.out.print("Enter owner name: ");
        return in.next();
    }

    static int readBalance(Scanner in) {
        System.out.print("Enter starting balance (cents): ");
        return in.nextInt();
    }

    static String readStatus(Scanner in) {
        System.out.print("Enter status (ACTIVE/CLOSED): ");
        return in.next();
    }

    static String readOpenedDate(Scanner in) {
        System.out.print("Enter opened date: ");
        return in.next();
    }
}




	Again, we are no longer passing the account to the deposit/withdraw/printAccount methods; rather we invoke the method on a specific account
	
This means that once we are inside the method, it is implicitly operating on that particular account and its attributes.
	As a result, the operations are no longer general-purpose functions; they are now tied to the account through which they are invoked.
	In other words, we are moving from “operate on this account” to “this account performs the operation.”


Achieving this involves a relatively simple change to the BankAccount class; specifically the methods:

class BankAccount {
    public void deposit(int amount) {balance += amount;}	// no static

    public void withdraw(int amount) {		// no static
        if (status.equals("CLOSED")) {
            System.out.println("Withdrawal denied: account is CLOSED");
            return;
        }
        balance -= amount;
    }

    public void print()  {
        System.out.println("Account #: " + accountNumber);
        System.out.println("Owner: " + owner);
        System.out.println("Balance: " + balance + " cents");
        System.out.println("Status: " + status);
        System.out.println("Opened: " + openedDate);
    }

    int accountNumber;
    String owner;
    int balance;
    String status;
    String openedDate;
}




    Notice the absence of static in the method headers.
        
            Earlier, our methods were written as general-purpose operations, so we had to pass the account they should operate on.
            
Now, each method is invoked on a specific account, so it automatically (implicitly) operates on that account’s attributes.
			
A static method is not associated with any particular account; it exists independently of any instance, and thus requires an account parameter.
				
					Because the methods above are tied to a particular account, they cannot be static.
				
            
Here is some terminology:
                
                    An account created using new is called an instance, or an object, of the class.
                    
The attributes of the class are called instance variables.
                    
The (non-static) methods of the class are called instance methods.
                
            
Most methods we write for a class will be instance methods; static methods are used less frequently and for different purposes
        
	
Several consequences of the method operating on the account on which it is inviked:
		
			There is no need to specify which balance is being operated on; it is the one belonging to the account the method is invoked on 
			
The methods can modify an account’s attributes directly. Since the method is invoked on a specific account, there is no need to return an updated value or assign the result back to the account;
				i.e., the state of the account upon whcih the method is involed is changed in place.
		
	
Now that our instance methods are invoked on an account, e.g., account.printAccount(), the Account suffix is unnecessary: account.print().



10 — Detour: An Array of BankAccount

And again, let's see the effect of all this on our array app:

import java.util.*;
import java.io.*;

public class BankAccountApp {
	public static void main(String[] args) throws Exception {
		Scanner in = new Scanner(new File("accounts.text"));

		final int CAPACITY = 100;

		BankAccount [] accounts = new BankAccount[CAPACITY];

		int size = 0;
		while (in.hasNextInt()) {
			accounts[size] = new BankAccount();
			readAccount(in, accounts[size]);
			size++;
		}

		System.out.println("-- After reading in and creating the accounts");
		printAccounts(accounts, size);

		System.out.println("--- Performing a deposit of 5000 on account at position 1");
		accounts[1].deposit(5000);
		printAccounts(accounts, size);

		System.out.println("-- Sorting by owner");
		sort(accounts, size);
		printAccounts(accounts, size);
	}

	// ---------------- Input ----------------

	static void readAccount(Scanner in, BankAccount account) {
		account.accountNumber = readAccountNumber(in);
		account.owner = readOwner(in);
		account.balance = readBalance(in);		  // cents
		account.status = readStatus(in);
		account.openedDate = readOpenedDate(in);
	}

	static int readAccountNumber(Scanner in) {return in.nextInt();}
	static String readOwner(Scanner in) {return in.next();}
	static int readBalance(Scanner in) {return in.nextInt();}
	static String readStatus(Scanner in) {return in.next();}
	static String readOpenedDate(Scanner in) {return in.next();}

	// ---------------- Output ----------------

	static void printAccounts(BankAccount [] accounts, int size) {
		System.out.println("ACCOUNTS");
		System.out.println("-------------");
		for (int i = 0; i < size; i++) { 
			accounts[i].print();
			System.out.println();
		}
	} 

	// ---------------- Sort ----------------
	
	static void sort(BankAccount [] accounts, int size) {
		boolean swapped = true;
		for (int last = size-1; size > 0 && swapped; size --) {
			swapped = false;
			for (int i = 0; i < last; i++)
				if (accounts[i].owner.compareTo(accounts[i+1].owner) > 0) {
					swap(accounts, i, i+1);
					swapped = true;
				}
		}
	}

	static void swap(BankAccount [] accounts, int idx1, int idx2) {
		BankAccount t = accounts[idx1];
		accounts[idx1] = accounts[idx2];
		accounts[idx2] = t;
	}
}




    This app differs only slightly from the previous version in which the
        account operations were still declared static.
    
The only changes are the calls that now invoke operations directly on an
        account:
        
            the call to deposit
            
the call to print an account
        
    
All other code is unchanged. The program still works with an array of
        BankAccount objects, and the overall structure of the app
        remains the same.

CISC 3115 Modern Programming Techniques Lecture 1 Motivating Classes

00 — Just a Simple App

01 — BankAccount: An App with Application Semantics

02 — Adding Additional Attributes

03 — What About Rules for Bank Account Operations?

04 — Detour: Multiple Accounts … Parallel Arrays

Sorting Parallel Arrays

05 — A First Step Towards a Solution … Isolating the Bank Account Methods

06 — The Next Step … Packaging the Attributes

07 — Merge Ops and Attributes

08 — Detour: Arrays

09 — Making Operations Account-Specific

10 — Detour: An Array of BankAccount

CISC 3115
Modern Programming Techniques
Lecture 1
Motivating Classes

01 — `BankAccount`: An App with Application Semantics

10 — Detour: An Array of `BankAccount`