CISC 3115 — Lecture 3 — Classes Part II

CISC 3115
Modern Programming Techniques
Lecture 1
Classes I — The Basics

Overview

In this lecture we're going to present a series of applications that are similar to those developed in CISC 1115, but quite different inteir perspective. We'll develop them and discuss various issues as we go along.

In the Absence of Classes: 1115-Like Apps

A Baseline, Generic 1115-like App (`App`)

Write an app that maintains an integer value that is modified through adding and subtracting values read in from a file named action.text Each entry in the actions file consists of an action A (for add) or S (for subtract), followed by the amount to be added/subtracted from the value.

import java.io.File;
import java.util.Scanner;

class App {
     public static void main(String [] args) throws Exception {
          Scanner scanner = new Scanner(new File("actions.text"));

          int value = 0;

          while (scanner.hasNext()) {
               String action = scanner.next();
               int amount = scanner.nextInt();

               if (action.equals("A")) {
                    value += amount;
                    System.out.println("Value after add of " + amount + ": " + value);
               }   
               else if (action.equals("R")) {
                    value -= amount;
                    System.out.println("Value after removal of " + amount + ": " + value);
               }   
          }   
     }    
}

Notes

In addition to the standard, ever-present boilerplate, there are two parts to this app:
- The I/O portion: creating and opening a Scanner object, reading in the actions and amount, and testing for termination
  - We've used standard, meaningful naming conventions for this part of the code; it should be fairly clear what's going on
- The processing and maintenance of the value.
  - Here we've used a generic variable name (value) as well as equally generic action descriptions (add and subtract). The latter is not surprising, given the former has no real semantics.
Baseline; introduces the basic read/action structure we'll use
As alluded to in the previous bullets, this program's semantics is generic in the sense that it has no application context (i.e., what are the numbers for, why would we be adding or subtracting amount).
- OTOH, it could be used in many contexts (as we shall see in a moment).
With regard to 1115 apps: the 30-point question, and most other late-in-the-semester apps that are written read in multiple values into an array, process them in some manner, often sort them, and then print some results. This app also reads a file of data, but in this case it consists of a series of operations on a single item (the value variable)

actions.text
A 200
S 50
S 70
A 10

Initial value: 0
Value after add of 200: 200
Value after subtraction of 50: 150
Value after subtraction of 70: 80
Value after add of 10: 90

Modelling 'Things': A Bank Account (`01-BankAccount`)

Borrowing from Above

o Let us take the above generic app and add specific semantics — that of a bank account — to it.

We'll accomplish this by introducing semantically-appropriate variable names and methods

Write an app named BankAccount that contains two methods named deposit and withdraw, both of which accept a balance and an amount and returns the amount added-to/subtracted-from the balance respectively. The main method should illustrate the methods by reading in actions (deposit and withdrawal) from a while and apply them to the account.

We speak of modelling a bank account

import java.io.File;
import java.util.Scanner;

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

		int balance = 0;

		while (scanner.hasNext()) {
			String action = scanner.next();
			int amount;

			switch (action) {
				case "D":
					amount = scanner.nextInt();
					balance = deposit(balance, amount);
					System.out.println("Balance after deposit of $" + amount + ": " + balance);
					break;
				case "W":
					amount = scanner.nextInt();
					balance = withdraw(balance, amount);
					System.out.println("Balance after withdrawal of $" + amount + ": " + balance);
					break;
				default:
					System.out.println("*** Error *** unknown action: " + action);
			}
		}
	}	

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

Notes

This is the identical class as the previous (App) modulo the names of the variables, and the extraction of the deposit/withdrawal logic into methods)
We introduce a switch just to show a switch (it's also the right construct to use in this context).
The introduction of a semantically-meaningful variable name (balance) puts a whole new face on the app
Additionally, the introduction of methods with equally meaningful names, provides more semantics understanding
- Even though the methods are trivial in implementation, this is another reason to introduce methods to provide semantic meaning to the operations being implemented.
- breaking up a larger piece of code into constituent methods is a technique known as procedural decomposition and is a primary technique in code rte song and organization for pre-OOP languages (as well as intra-class code).
neither naming conventions nor procedural decomposition are language-enforced.
Notice how a 'thing' emerges here: a bank account with a balance manipulated through depot/withdrawal actions
- This is primarily a result of adding semantically meaningful names and isolating the operations into their own methods
- There are several parts to this 'thing':
  - The methods themselves
  - The initialization of the balance
  - The display of the balance
All methods are declared static (we're going to discuss this more later)
The process of dividing tasks or logical sections of code into methods is known as procedural decomposition.
- This was one of the first approaches for organizing code.
We can't write the methods as common-sense would dictate:
```
public static void deposit(int balance, int amount) {balance += amount;}
		
```
- Java passes primitives by-value which means that changes to parameters do not persist upon returning to the calling method (i.e., the calling arguments are not changed by changes to the parameters). Given the method:
```
static void f(int i) {
	i++;
}
					
```
  The call to f:
```
int i = 10;
f(i);		// does NOT change i
System.out.println(i); // prints 10
					
```
- The only way of passing a value back from a method to the caller is via the return value of the method.
- This means that the only way (for the moment at least) to have the change to a primitive parameter return to the calling method is to return it explicitly in a return statement.
```
static int f(int i) {
	return i+1;
}
					
```
  The call to f:
```
int i = 10;
i = f(i);		// assigns the new (returned value to i)
System.out.println(i); // prints 11
					
```
  - Having the return value only also restricts us to returning only one such change (again for the moment).
Just for emphasis, had we omitted using methods,we could have simply written in main balance += amount
To sort of 'add insult to injury', balance needs to be sent to the methods together with the amount of the transaction (and then assigned its new value from the return value of the method)
Notice all methods are declared static
As an aside, a skill we need to develop is to start figuring out both the methods we need as well as their interfaces (i.e., signatures). In addition to the issues related to the application (e.g. banking transactions), we also have to take into account the technical aspects — such as the effect of call-by-value — on the signature and thus the interface of the entity we're communicating with.
Working with two or more bank accounts is possible (have more balance variables) but quickly proves unwieldy, even if we introduce arrays (we'll see that in a bit).

Do the methods buy us anything?

We have to send the balance and transaction amount to each (remember the 'complex' signature and need for a return value; why not just do it in-place?
Isolating (and thus 'hiding' the logic of) the operations and assigning them descriptive names provides a whole level of readability and comprehension
- For example, modifying the withdrawal logic to prevent overdrawing (i.e., withdrawing more than the balance) would involve changing the logic of the method; the caller is unaffected
```
public static int withdraw(int balance, int amount) {
	if (balance >= amount) 
		return balance - amount;
	else
		return balance;
}
						
```

Another Sort of 'Thing': A Fuel Tank

Here is another version of the generic app with specific semantics; this time that of a vehicle's fuel tank.

import java.io.File;
import java.util.Scanner;

class FuelTankApp {
		Scanner scanner = new Scanner(new File("fueling_actions.text"));

		int tank = 0;
		System.out.println("Initial tank: " + tank + " gallons");

		while (scanner.hasNext()) {
			String action = scanner.next();
			int gallons;

			switch (action) {
				case "F":
					gallons = scanner.nextInt();
					tank = fill(tank, gallons);
					System.out.println("Tank after fueling " + gallons + ": " + tank + " gallons");
					break;
				case "C":
					gallons = scanner.nextInt();
					tank = consume(tank, gallons);
					System.out.println("Tank after consuming " + gallons + ": " + tank + " gallons");
					break;
				default:
					System.out.println("*** Error *** unknown action: " + action);
			}
		}
	}	

	public static int fill(int tank, int gallons) {return tank + gallons;} 
	public static int consume(int tank, int gallons) {return tank - gallons;}
}

Notes

operationally identical operations, but a different 'thing'
imagine an app with bot bank accounts and fuel tanks — keeping the variables in the 'proper places'.

Moving Related Methods to their Own Source Files; Separate Compilation

We now extract the bank account-related methods and place them in their own class.

This emphasizes the notion of these methods as operating on bank accounts

class BankAccount {
	public static int deposit(int balance, int amount) {return balance + amount;}
	public static int withdraw(int balance, int amount) {return balance - amount;}
}

import java.io.File;
import java.util.Scanner;

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

		int balance = 0;

		while (scanner.hasNext()) {
			String action = scanner.next();
			int amount;

			switch (action) {
				case "D":
					amount = scanner.nextInt();
					balance = BankAccount.deposit(balance, amount);
					System.out.println("Balance after deposit of $" + amount + ": " + balance);
					break;
				case "W":
					amount = scanner.nextInt();
					balance = BankAccount.withdraw(balance, amount);
					System.out.println("Balance after withdrawal of $" + amount + ": " + balance);
					break;
				default:
					System.out.println("*** Error *** unknown action: " + action);
			}
		}
	}	
}

Notes

essentially, all we've done is move the methods into their own source file.
- Code outside of that file invokes the methods by prefixing their class name
```
class BankAcct {
	static int deposit(…
		…
				
```
  we could invoke this method from elsewhere (e.g. main via:
```
BankAccount.deposit(…
				
```
  as you can see in the above BankAccountApp code
This separate compilation facility means that one needn't recompile the entire body of code each time a change is made to the body of a method; only the class containing that method
- Changes made to the interface (signatures) of methods may cause additional compilations as well

Two 'Things' in the Same App

In the above apps, main is busy dealing with the value of the 'thing' we are modelling. Now imaging an app which requires bank accounts AND fuel tanks. main would have to make sure it properly handles the two things, i.e., not sending a balance to a fillUp method, or a fuel tank level to a withdraw method.

A more realistic scenario would be two different sorts of bank accounts:

class SavingsAccount {
	public static int deposit(int balance, int amount) {return balance + amount;}
	public static int withdraw(int balance, int amount) {return (amount <= balance) ? balance - amount : balance;}
}

class CheckingAccount {
	public static int deposit(int balance, int amount) {return balance + amount;}
	public static int withdraw(int balance, int amount) {return balance - amount;}
}

import java.io.File;
import java.util.Scanner;

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

		int 
			savingsBalance = 0,
			checkingBalance = 0;

		while (scanner.hasNext()) {
			String action = scanner.next();
			int amount;

			switch (action) {
				case "SD":
					amount = scanner.nextInt();
					savingsBalance = SavingsAccount.deposit(savingsBalance, amount);
					System.out.println("Balance after deposit of $" + amount + ": " + savingsBalance);
					break;
				case "SW":
					amount = scanner.nextInt();
					savingsBalance = SavingsAccount.withdraw(savingsBalance, amount);
					System.out.println("Balance after withdrawal of $" + amount + ": " + savingsBalance);
					break;
				case "CD":
					amount = scanner.nextInt();
					checkingBalance = CheckingAccount.deposit(checkingBalance, amount);
					System.out.println("Balance after deposit of $" + amount + ": " + checkingBalance);
					break;
				case "CW":
					amount = scanner.nextInt();
					checkingBalance = CheckingAccount.withdraw(checkingBalance, amount);
					System.out.println("Balance after withdrawal of $" + amount + ": " + checkingBalance);
					break;
				default:
					System.out.println("*** Error *** unknown action: " + action);
			}
		}
	}	
}

Notes

The difference in logic of the two withdrawal methods (the savings account does not permit a withdrawal that is larger than the balance) distinguishes between two types of 'things': savings accounts and checking accounts.
Imagine a main method trying to work with 2 Savings Accounts and three Checking Accounts.
- To add to the complexity, imagine checkng accounts each have an overdraft limit, i.,e., the maximum amount of money that can be withdrawn on a zero balance. This would introduce another variable to be maintained for each checking account.

Let's Add One more Layer: An Array of BankAccounts

Introducing an Array of 'BankAccount's raises all sorts of challenges and opportunities.

import java.io.File;
import java.util.Scanner;

class BankAccountsApp {
	public static void main(String [] args) throws Exception {
		Scanner scanner = new Scanner(new File("bank_actions.text"));

		final int CAPACITY = 100;
		int size = 0;
		int [] balances = new int[CAPACITY];
		int [] ids = new int[CAPACITY];

		while (scanner.hasNextInt()) {
			int id = scanner.nextInt();
			String action = scanner.next();
			int amount;

			int index = search(ids, size, id);
			if (index == -1) {
				size = add(ids, balances, size, id, CAPACITY);
				index = size-1;
				System.out.println("Added account " + id + " with balance of $0 at location " + index);
			}

			switch (action) {
				case "D":
					amount = scanner.nextInt();
					balances[index] = BankAccount.deposit(balances[index], amount);
					System.out.println("Balance of account " + id + " after deposit of $" + amount + ": $" + balances[index]);
					break;
				case "W":
					amount = scanner.nextInt();
					balances[index] = BankAccount.withdraw(balances[index], amount);
					System.out.println("Balance of account " + id + " after withdrawal of $" + amount + ": $" + balances[index]);
					break;
				default:
					System.out.println("*** Error *** unknown action: " + action);
			}
		}
		System.out.println();
		print(ids, balances, size);
	}	

	static int search(int [] ids, int size, int id) {
		for (int i = 0; i *lt; size; i++) 
			if (ids[i] == id) return i;
		return -1;
	}

	static int add(int [] ids, int [] balances, int size, int id, int capacity) {
		if (size == capacity) {
			System.err.println("Capacity reached; make arrays larger");
			System.exit(1);
		}
		ids[size] = id;
		balances[size] = 0;
		return size+1;
	}
		
	static void print(int [] ids, int [] balances, int size) {
		for (int i = 0; i *lt; size; i++)
			System.out.println(ids[i] + ": $" + balances[i]);
	}
}

Notes

The BankAccount class with the two methods is as above
An array of bank accounts means there must be a way to distinguish between them and then identify them, i.e., an ID of some sort.
- This, in turn, introduces at least two parallel arrays, i.e., arrays in which the i'th row across the arrays (hence the term parallel) corresponds to the i'th data item.
- The actions file must take the id into account and add it as an additional field of the input record for each transaction
We have no idea how many accounts we will encounter in the actions file; we assume some fixed capacity and use a running size variable to maintain the actual number of elements (accounts) have been added to the array
- Since arrays start at 0, the size variable also represents the first empty location in the array; or to put it another way, the location where the next account will be placed.
- capacity is also sometimes called physical size in which context size is then called logical size.
Once we have our data structure set up: an array of fixed capacity, and an accompanying size variable, the logic of our app and methods becomes fairly straightforward:
- Add 'reading in the account id' to the read logic
- Search for the account in the array
  - If not there, add the new account to the id arrays and set the corresponding element of the balance array to 0
- Send the corresponding balance to the appropriate methods based on the action
Notice that we are just about at the 1115 30-point app now … an array of items (bank accounts in the form of id's and balances)
- The main difference is that we;re not preloading the array with the accounts; rather building it up as we go along.
- Not a big deal, just a slightly different technique for adding items to the array.
We introduce a print method to print out the accounts after all action processing is completed
- The print methods requires all the information about the bank account: the id and the balance, and thus two arrays need to be sent to the method (only one size is necessary as they are parallel arrays). If there was more information accociated with the account (e.g., overfraft limits), an array would be sent as an argument for each such piece of information.
  - This would quickly get out of hand in a real bank account model
- Note the print method is making its own decision on what it means to print out an account.
What about modifying the BankAccount methods?, e.g.:
```
public static void deposit(int [] balance, int index, int amount) {balances[index] += amount;}
		
```
we could then call it as follows:
```
BankAccount.deposit(balances, index, amount);
		
```
- The issue is that the signature of this method doesn't properly belong in a BankAccount class … it limits itself to elements of an array of BankAccount
  - This is the kind of thing is what I was talking about when I talked about developing the skill of class and method design
- One COULD place the above method in the BankAccounts class (which handles arrays of BankAccounts) and have that method call the corresponding method in BankAccount:
```
// In BankAccounts
void deposit(nt [] balances, int index, int amount) {
	balances[index] = BankAccount.deposit(balances[index], amount);	the usual BankAccount method
}
				
```
  this makes the interface cleaner for users of BankAccounts (which is probably the usual way people use BankAccount, i.e., via an array of them
  - The above is a technique known as wrapping, or delegation nd the method is therefore called a wrapper or delegation method. (There's a subtle difference between the two two that we'll examine later).
A final note … as with the simple BankAccount app, main is doing way more than it should; in that case, maintaining the bank account's data (the balance); here, main is responsible for the array, again, too much.
- In both cases, there's a 'thing' associated with the data main is dealing with: a bank balance on in the one case, and a collection of bank accounts in the other

actions.text

Added account 1001 with balance of $0 at location 0
Balance of account 1001 after deposit of $200: $200
Added account 1030 with balance of $0 at location 1
Balance of account 1030 after deposit of $100: $100
Balance of account 1030 after withdrawal of $50: $50
Balance of account 1001 after withdrawal of $70: $130

1001: $130
1030: $50

Classes: Overview From 10,000 Feet

We are now going to do the same thing with the data of our 'thing' as we did with the methods that operate on it; i.e., place it into a separate class together with those methods. This combination of known as a class and the purpose of the class is to create objects that posses the behavior and characteristics, i.e, data (state) and methods (behavior), specified in the class definition.

Here are the semantics of defining and using a class in a nutshell:

The value(s) associated with our ;thing' (balance for BankAccount) are added to the class containing the methods that operate on it.
Now that it no longer a local variable, it is accessible to all the methods within the class, and thus need not be passed as a parameter to the method anymore.
The resulting specifications used to create objects, each of which has its own balance variable. The methods are shared among all the objects.
one calls a method on an object and the method operates on the values of the variables contained in that particular object
objects are created using the new keyword

public class BankAccount {
	public void deposit(int amount) {balance += amount;}
	public void withdraw(int amount) {balance -= amount;}

	public int getBalance() {return balance;}

	private int balance = 0;
}

Notes

variables declared within the class (as opposed to inside a method; in this case the variable balance, are called instance variables
- each object of the class has its own copy of the instance variables
private indicates that the only methods that can access the variable (balance) are the methods of the class itself.
public means the method may be called from outside the class.
In general data is declared private and methods public.
The variable balance is initialized at the point of declaration to 0.
The method getBalance is added to allow outside code (main in our case) to get information from the object (the variable cannot be accessed directly since it is private).
Since balance is an instance variable (i.e., a member of the class), the methods of the class have direct access to its value … to both access and modify it.
- That is why it no longer appears in the parameter list of the methods, nor do we have to return a value to assign to it … the methods directly access and modify it.

Here is the app using the class:

import java.io.File;
import java.util.Scanner;

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

		BankAccount account = new BankAccount();

		while (scanner.hasNext()) {
			String action = scanner.next();
			int amount;

			switch (action) {
				case "D":
					amount = scanner.nextInt();
					account.deposit(amount);
					System.out.println("Balance after deposit of $" + amount + ": " + account.getBalance());
					break;
				case "W":
					amount = scanner.nextInt();
					account.withdraw(amount);
					System.out.println("Balance after withdrawal of $" + amount + ": " + account.getBalance());
					break;
				default:
					System.out.println("*** Error *** unknown action: " + action);
			}
		}
	}	
}

Notes

Typical way to introduce a variable and object:
- Declare the reference variable
- Create the object using new and use the resulting reference to initialize the reference variable
Working with several BankAccount objects merely requires declaring reference variables for each, creating an object for each, and assigning its reference to the variable
Calling (invoking) a method on an object involves executing the method in the context of the object; i.e., the instance variables used in the method's code are those of the object being invoked.
- We call the object being invoked the receiver
- The syntax for the invocation is:
```
receiver.method(arguments)
				
```
  for example:
```
account.deposit(100)
				
```
  - We speak of sending the message deposit(100) to the receiving object (i.e., the receiver) account.

We discussed above the issue of having more than one 'thing' in the same app, and presented it in the context of a savings and checking account. We now present the SavingsAccount and CheckingAccount examples using classes. We will also introduce the approach for printing out objects in general.

While there may be other reasons to access the balance, the sole purpose of getBalance was to allow the app to access the balance in order to print it.
In general, a class should provide a representation of the object as a string for the purposes of printing or writing to a file.
- This is done by defining the method toString in the class:
```
public String toString();
				
```
- Note the absence of any parameters; the method constructs a string representation of the object so no external information is required.
- The resulting string is then typically passed as an argument to println to print out the 'value' of the object.

class SavingsAccount {
	public void deposit(int amount) {balance += amount;}
	public void withdraw(int amount) {if (amount <= balance) balance -= amount;}
	
	public String getBalance() {return "$" + balance;}

	private int balance = 0;
}

class CheckingAccount {
	public void deposit(int amount) {balance += amount;}
	public void withdraw(int amount) {balance -= amount;}
	
	public String getBalance() {return "$" + balance;}

	private int balance = 0;
}

Notes

toString is generally defined on every class
It typically concatenates the values of its instance variables (often all, sometimes only some if they are irrelevant or to be hidden from the outside).
Remember, when concatenating a String ($ in this case) with a non-String (the int balance here), the non-String is converted to String

import java.io.File;
import java.util.Scanner;

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

		SavingsAccount savingsAccount = new SavingsAccount();
		CheckingAccount checkingAccount = new CheckingAccount();

		while (scanner.hasNext()) {
			String action = scanner.next();
			int amount;

			switch (action) {
				case "SD":
					amount = scanner.nextInt();
					savingsAccount.deposit(amount);
					System.out.println("Balance after deposit of $" + amount + ": " + savingsAccount);
					break;
				case "SW":
					amount = scanner.nextInt();
					savingsAccount.withdraw(amount);
					System.out.println("Balance after withdrawal of $" + amount + ": " + savingsAccount);
					break;
				case "CD":
					amount = scanner.nextInt();
					checkingAccount.deposit(amount);
					System.out.println("Balance after deposit of $" + amount + ": " + checkingAccount);
					break;
				case "CW":
					amount = scanner.nextInt();
					checkingAccount.withdraw(amount);
					System.out.println("Balance after withdrawal of $" + amount + ": " + checkingAccount);
					break;
				default:
					System.out.println("*** Error *** unknown action: " + action);
			}
		}
	}	
}

Notes

println is overloaded to accept any object as its argument, in which case it invokes the object's toString method and prints the resulting String.

Classes: The Details

Introduction

We've introduced the notion of a class. The basic idea is to bundle together logically/semantically-related variables and methods into a single entity that represents or models specific the desired behavior. One fundamental change is to take the principal values of our proposed object (i.e., entity) and place them at the class level rather than as local variables; in effect making them available to all the methods in the class (assuming we remove the static keyword from their header — see below). Most of the other changes are then a consequence of this change.

Summarizing the introductory bank account example above:

The primary (actually only in this case) value is the balance; we move it out of main (where it was a local variable) and into the body of the BankAccount class.
- Such variables are called instance variables
Instance variables are visible to all the methods of the class, and can be manipulated by them
- As such, they do not need to be passed as parameters to the methods; they are directly accessible
- The result is a substantial reduction in the number of arguments, often going to 0
  - For someone who has been programming procedurally, i.e. , in the manner of 1115 as presented at the beginning of this lecture, This takes some getting used to
  - Again, this reduction in parameters is because the state of the object is being maintained in the instance variable, there's no need to pass anything to the method (other than external information, e.g. the amount of a deposit or withdrawal; that is NOT part of the state of the object)
Creating an object or instance of the class is a familiar operation:
```
classname identifier = new classname(…);
		
```
for example:
```
BankAccount bankAccount = new BankAccount();
		
```
- This creates a new instance of the class with its own copy of the variables (which is why they're called instance variables — each instance has its own set of them.
Note the absence of static on the method headers; these are known as instance methods and will operate on a particular instance's variables.
Invoking (calling) a method on a particular instance is also familiar:
```
bankAccount.deposit(amount);
		
```
- The instance variable (balance that is used in the method is the one associated with the instance referenced by bankAccount
- We call the object upon which we are invoking the method the receiver (of the method).
We do not want to allow any outside code to directly manipulated the value of balance so we declare it private
- Only the instance methods of the class can access private instance variables
The instance methods of the class are declared public so that they can be invoked from outside the class.
We introduce a method named toString. This method returns a String representation of our object
- The exact nature of the representation is up to the class designer (us in this case).
  - For this class, we choose to return balance preceded by a $
- For reasons that will become clear later on, toString must be declared public
The method main does not implement an operation of the class; rather it is a method that uses the class
- In particular, we would not invoke main in the following manner:
```
BankAccount bankAccount = mew BankAccount();
bankAccount.main();
				
```
- Rather main a class that we are using to illustrate use of our BankAccount class.
  - There is no receiver, so in some sense, main is 'separate' from the class (i.e., it does not operate directly on the instance variables of the class), and to indicate that, we declare it static
    - This is an imprecise explanation of what is happening; a better explanation will be forthcoming shortly

Revisiting 'Some Things to Think About'

What if you wanted two bank accounts?

Simply create two BankAccount objects:

BankAccount account1 = new BankAccount();
BankAccount account2 = new BankAccount();

What about twenty of them?
- Create an array of BankAccount objects:
```
BankAccount [] accounts = new BankAccount[100];
				
```
- We'll address arrays and objects below
What about a savings account and a checking account, i.e., with and without overdraft?
- Have two classes and create the corresponding objects: SavingsAccount savingsAccount = new SavingsAccount(); CheckingAccount checkingAccount = new CheckingAccount();

Terminology

class — repository of behavior and state
object / instance — an entity whose type is a class
- One creates an instance of a class (in Java using the new operator
state — data associated (stored within) an object
- Each instance has its own copy of the class' state (data, typically variables)
- These state variables are thus called instance variables
behavior — means by which the object interacts with the world. Achieved through the object's methods
- Behavior (the set of methods) is shared among all objects/instances of the class
- These methods operate on the instance variables of a particular object and are therefore called instance methods
- The invocation (calling) of a method on a particular object is achieved by the following syntax: object.method(arguments)
  - The object in the above is called the receiver and the method and its arguments are called the message.
  - Thus, the receiver receives the message and executes the method specified in the message passing it the supplied arguments.
We sometimes speak of the instance variables and methods as the fields of the class.
- As an aside, there are other types of fields as well, e.g., the length field of an array

Responsibility-Driven Programming

We want the object to be responsible for its own behavior and integrity.

Outside world should not be able to modify an object's state.
Interaction should only occur through the object's (i.e., classes) methods.
Classes should be designed to do one thing, but do it well.

Data Access

A consequence of an object being responsible for its own behavior is the need to control access to the object from the outside. This leads to the notion of data access specification — indicating what entities are allowed what sort of access to the state/behavior of the object.

public — entity is accessible to all
private — entity is accessible only to objects of the class
package-protected — entity is accessible to others in the same package
- this is the access; i.e., the access used when no data-access keyword is used
- we'll address this data access mode in a bit more detail later on

Class Definition

Basic syntax

class classname {
	methods

	variables
}

Example: Defining a Class

public class Name {
	public String getFirst() {return first;}		// Behavior
	public String  getLast() {return last;}
	public void setFirst(String f) {first = f;}
	public void setLast(String l) {last = l;}

	private String first, last;					// State
}

public class Counter {
	public up() {val++;}					// Behavior
	public int getVal() {return val;}

	private int val = 0;					// State
}

Notes

The methods getFirst/getLast are known as getter or accessor methods, while setFirst/setLast are called setter or mutator methods.
- Defining getters only provides read-only access; setters only allows write-only access, and bot provides unrestricted access to the to the corresponding instance variables
- Getter/setter methods are used in Java frameworks (i.e., a structured collection of Java software / libraries that provides convenient and productive support to the creation of Java apps.
- They are also considered low-level methods as they provide a view of the implementation of the class (i.e., the low-level details of the class).

Within the body of an instance method, we are in the context of the class, i.e., we can simply refer to the instance variables or methods of the class without any further specification
- i.e., in the above code, when we refer to first or val we are referring to those instance variables or the object upon which the method was invoked; e.g. if we had written name.getFirst() (i.e., calling getFirst on the objectname, the reference to first in the method is thefirst instance variable associated with the instance name.
- We will discuss this below in more detail in the section on scope.
Within the body of a method of the class, you can access the private variables of the class
- That is the only place the private instance variables may be accessed.

Classes as Types

We can think of a class definition as defining a new data type
We can then declare variables of the class type.
These variables will then refer to objects of the class.
```
Name name1, name2;

Counter c1;
		
```
- Keep in mind, these variables do not contain the obejcts, but rather references to objects.

Objects (Instances)

An object of a class is called an instance of the class.
Simply declaring a variable does not actually create an object of the class.
We create instances of the class and then refer to them.
The variable will act as a reference to objects of the class.
- The typical flow is we declare a reference variable, create an object of the corresponding class, and the reference resulting from that creation is the initializtion of the reference variable
```
SomeClass sc = new SomeClass();
				
```
We thus speak of reference variables
- Note … reference variables do not contain objects, rather references to objects.
Within the methods of a class, one can access the private variables of another instance of the same class

Creating Instances (Objects) of a Class

Objects are created using the new operator
```
new Name()

new Counter()
			
```
When new is done, it returns a reference to the newly created object.
This reference can then be assigned to a reference variable of the class.
```
Name name = new Name();

Counter c = new Counter();
		
```
Each created instance of the class has its own set of instance variable, distinct from those of any other instance.
```
Name 
	name1 = new Name(), 
	name2 = new Name();

Counter 
	c1 = new Counter(),
	c2 = new Counter();
		
```
- name1 and name2 are two instance with their own copies of the first and last instance variables of the class.
- Similarly, c1 and c2 are two instance with their own copies of the val instance variable of the class.

Example: Using a Class

Once an instance of a class is created, it's public fields (typically the methods) may be accessed.
When calling a method, we need to specify the object (instance) whose instance variables we wish to work with.
- This is accomplished by specifying the desired instance as the receiver of the message (i.e., the method and its arguments.
```
name1.getFirst();		// name1 is the receiver here, getFirst will access name1's instance variables
name2.getLast();		// name2 is the receiver here, getLast will access name2's instance variables

System.out.println(c1.getVal());	// c1 is the receiver
System.out.println(c2.getVal());	// c2 is the receiver
				
```
- Expanding a bit on what we said above, upon entering the method, we are in some sense in the context or scope of the receiver, i.e., all reference to the class' instance variables refer to the receiver's copy.
  - We will discuss this below in more detail in the section on scope.
- Furthermore, all instance methods of the class can be called without having to refer to the receiver (since we already know which object is the receiver).
Methods (i.e., their code) are 'shared' among all objects of the class; i.e., all objects/instances use the same methods.

public static void main(String [] args) {
	Name name1 = new Name();
	name1.setLast("Arnow");
	name1.setFirst("David");
	System.out.println(name1.getFirst());
	System.out.println(name1.getLast());
	Name name2 = new Name();
	name2.setLast("Weiss");
	name2.setFirst("Gerald");
	System.out.println(name2.getFirst());
	System.out.println(name2.getLast());
	Name name3 = name1;
	System.out.println(name3.getFirst());
	System.out.println(name3.getLast());
}

public static void main(String [] args) {
	Counter c = new Counter();

	for (int i = 1; i <= 10; i++)
		c.up();

	System.out.println(c);
}

Each of the above can go in separate classes from the class they use:

class NameApp {
	public static void main(String [] args) {
		Name name1 = new Name();
		…
	}
}

class CounterApp {
	public static void main(String [] args) {
		Counter c = new Counter();
		…
	}
}

or they can be placed in the corresponding class definition itself, acting as an illustration of how to use the class

class Name {
	…
	public static void main(String [] args) {
		Name name1 = new Name();
		…
	}
}

class Counter {
	…
	public static void main(String [] args) {
		Counter c = new Counter();
		…
	}
}

The current best practice is to place the main method in a separate app class
- This keeps the class from getting cluttered, it also prevents inadvertent use of private instance variables in main

The `main` Method as App

Any class can have a main method which must be declared as

public static void main(String [] args) {
	body
}

A program (application) is executed by invoking the interpreter on a class containing a main method. Execution begins at that method.

Primitive Types and Reference Types

Types that have direct machine representation (e.g. integers, floating point, characters, and booleans) are so represented in that fashion (rather than being defined by a class),
- These are called primitive types
- ; their values are primitive values and their variables primitive variables
Thus there are two distinct categories: reference types/values/variables and primitive types/values/variables.
- Primitive values are operated upon by operators: +, *, !, &&, etc..
- Reference values are manipulated by invoking the methods of the corresponding class.

References, Objects, Aliases

assignment merely copies the reference to the existing object
```
Name name1 = new Name("Weiss", "Gerald");
Name name2 = name1;
		
```
- There's still only one object here; name1 and name2 both contain references to it
- Variables that refer to the same object (as in this case) are called aliases.
new is the only way of creating objects
```
Name name1 = new Name("Weiss", "Gerald");
Name name2 = new Name("Weiss", "Gerald");
		
```
- In this example, there are two separate, distinct object created
- We say they are equal but not identical
we typically define equality as representing the same value
- what representing the same value means is up to the designer of the class
- In the above Name example, equality means having the same last and first names
- We sometimes speak of semantic equality, i.e., the equality of the to objects is based upon the meaning of the objects — what it means for two objects of the class to be equal
- the method equals is usually defined (by the class designer) to test for (semantic) equality):
```
name1.equals(name2)
				
```

In the following case, the objects are neither identical nor equal:

Name name1 = new Name("Weiss", "Gerald");
Name name2 = new Name("Arnow", "David");

Objects can be equal but not identical, but they can't be identical and not equal

Object Initialization

Suppose we wish to be able to create a bank account with an initial non-zero balance, We could add a setter method and write:

BankAccount account = new BankAccount();		
account.setBalance(100);

Notes

Recall, the balance instance variable is initialized to 0 at the point of the instance variable's declaration.
The setter subsequently permits us to change the balance

There are several issues with the above approach:

Most importantly, introducing the setter method, setBalance now opens the door for any code to modify balance, toally violating encapsulation
We have to remember to perform the setBalance after the creation of the object , rather than having the balance initialized when the object is created.

In this particular situation, one COULD avoid the need for a setter and instead perform a deposit after object creation:

BankAccount account = new BankAccount();		
account.setBalance(100);

While this preserves encapsulation (i.e., we are still limited to performing a 'sanctioned' operation , i.e., deposit, rather than the 'free-for-all' setBalance), there are still some drawbacks to this approach:

One can still neglect to call deposit after object creation
- In this situation, the balance may default to 0 which is incorrect (there's supposed to be an initial balance); in other classes, the instance variables may remain completely uninitialized which would be totally unacceptable.
It may not be the case that doing a deposit after object creation is the same thing as providing an initial balance (at object creation). For example, deposits may incur a fee, but not the initial balance. Or, the bank customer might receive some sort of gift depending on the size of the initial balance.

Note also, that we cannot provide this initial balance at the point of declaration as it will typically be different from object to object (one bank account may be opened with an initialize balance of $100; another with $500).

What we need (and want) is the ability to initialize an object at the point of its creation, i.e., at runtime, rather than textually (at edit/compile time).,

`Constructors` — Initializing Objects

After new creates the object it invokes a method, known as a constructor that initializes the object (i.e., its instanceV variables)
```
Counter c = new Counter();
		
```
```
Name name = new Name();
		
```
- The constructor is automatically invoked by new-- the programmer does not call it directly.
- The above syntax does not represent a call to the constructor; rather it is a call to new passing it the name of the class whose object is to be created, as well as the arguments to the constructor which will be called as part of the creation process.
The name of the constructor method is identical to the name of the class
```
Counter() {val = 0;}
		
```
```
Name() {
	first = "";
	last = "";
}
		
```
- In both of the above classes, we would have probably initialized the instance variables at the point of declaration, i.e.,
```
class Counter {
	…
	private int val = 0;
}
				
```
```
class Name {
	…
	private String first = "", last = "";
}
				
```
  in which case, there would be no need for any code in the constructor. In such an instance, we can often omit the constructor entirely (more on that below).

Default Constructors

The above constructors above took no arguments
- Constructors with no arguments are known as default constructors
- Default constructors are good for simple creation of an object
  - They allow a user without much knowledge of the class to create objects of the class with little effort.
- In the above classes, the values to be used to initialize the objects were the same for all objects, and thus initialization at point-of-declaration was possible

Constructors with Arguments

More often, however, object creation requires initialization that must be supplied at runtime

Constructors can thus also have arguments

Name(String l, String f) {
	last = l;
	first = f;
)

Constructor Overloading

One may wish to allow the user to create instances of a class in one of several ways.

For example, for the following Counter class, one might want to be able to create a counter with an initial value, or simply create a counter whose value defaults to 0.
```
class Counter {
	…
	private int val;	// value of the counter
}
		
```
- In the latter case, one could use a default constructor:
```
Counter c1 = new Counter();
				
```
  while the former case would be:
```
Counter c2 = new Counter(10);			// create a Counter instance with an initial value of 10
				
```
The straightforward way to do this is to have each constructor perform the initialization on its own:
```
Counter(int v) {val = v;}
Counter() {val = 0;}
		
```
However, this approach often leads to duplication of logic, and if the logic is involved or lengthy that leads to maintainability and readability issues.
Here is another example
- Point: we create Point objects by specifying their x and y values. One could imagine that not specifying any x/y might create a point at the origin (0, 0):
```
Point() {
	this.x = 0;
	this.y = 0;
				
```
  }
Constructor Overloading and this
- An alternative is to have as much of initialization occur in one of the constructors and allow the other constructor(s) to call it supplying any necessary data:
```
Counter(int v) {val = v;}
Counter() {this(0);}
		
```
  - The keyword this is a reference to the current object (i.e., the receiver).
  - In the case of constructor overloading, we use this to specify that we are calling another constructor from the current constructor.
    - Note how the two constructors differ in signature (i.e., parameter lists), and thus when we write this(0), it is clear to the compiler that we are invoking a different constructor (the one that accepts an int parm).
  - We will encounter other (similar) uses of this later on.
The Names of the Constructor Parameters
- Notice in the above examples, the names of the constructor arguments were different than the names of the instance variables they were being used to initialize (v vs val; f, l vs first, last).
- However, there is a school of thought (accepted and prevalent in Java) whose goal is to keep the code clean, readable and consistent. Rather than coming up with alternative names that 'mean the same', we use the same names.
  - The problem is distinguishing between the instance variables and the parameters that are local to the method.
  - We again use the keyword this to refer to the receiving object within a method
    - In our context, it is used to 'bypass' the reference to the parameters
      - The resolution of which variable we are referring to works outwards: in a method we start at the locals, then outwards to the instance (and possibly class) variables.
      - Using this informs the compiler (and us) to skip the locals and begin the resolution process at the receiving object.
  - This technique involves a working knowledge of scope which we discuss below.
Overloaded Constructors
- There are often several ways of creating an object:
  - Point: we create Point objects by specifying their x and y values. One could imagine that not specifying any x/y might create a point at the origin (0, 0):
```
Point() {
	this.x = 0;
	this.y = 0;
}
				
```
  - Like other methods, constructors may be overloaded, i.e., two or more methods of the same name may be defined as long as their signatures differ.
Leveraged Constructors
- Even further, it is often the case that the overloaded constructors contain much of the same logic. Rather than repeating the logic, we can often place the logic in one constructor (sometimes called the workhorse and then
  leverage that logic from the other constructors (again, leveraging and delegation are related: when one method delegates to another, it is leveraging the other's logic).
```
Point() {this(0, 0);}
		
```
  - The above constructor delegates it task of initializing the x and y to 0 by calling the two-argument constructor (the one we placed in the Point class above)
  - We use this (rather than Point to indicate that we are invoking another constructor of the object we are initializing.
Default Constructor
- A 0-parameter constructor is called a default constructor
  - This is because one relies on the class definition to supply default initial values to the state of the class.
  - This is useful for new users of the class and classes with complex configurations / values
Copy Constructor
- When we write:
```
Point p = new Point(10, 20);
Point p2 = p;
		
```
  p2 become an alias of p, i.e., the two reference variables are now referring to the same object.
- If we want two separate copies (i.e., p and p2 refer to separate objects), we can write:
```
Point p2 = new Point(p.getX(), p.getY());
		
```
  but that requires:
  - We have the getter methods getX and getY, and
  - We know how to build Point objects
  What we really want to do is copy the object referred to by p to a new object and have p2 refer to it, i.e.:
```
Point p2 = new Point(p);
		
```
  - the above constructor is called a copy constructor and its implementation is:
```
Point(Point p) {
	x = p.x;
	y = p.y;
}
				
```
    or (leveraging):
```
Point(Point p) {this(p.x, p.y);}
				
```
  - Take note of the parameter to the copy constructor; it is another object of the same class. This makes sense as what we are doing is initializing an object of the class using the values of another object of the same class.
    - This can be a touch confusing at the beginning
    - However, it's also an important facility; we will see it (i.e., parameters of the same class in the methods of a class) again in a bit
The toString Method
Most classes have a method named toString defined by their designers.
- The purpose of this method is to produce and return a string representation of the class.
- The signature of the method is public String toString()
== and the equals Method
- Again:
  - reference variables contain references to objects (or null — see below — in the absence of such a reference)
  - primitive variables contain the actual values they operate on
- for primitive types, the == operator compares the primitive values, which is the correct semantics; i.e., i == 4, d == 12.4
- for reference types, the == operator also compares the values, however, in this case, it's a reference so we are effectively comparing if the two value (references) refer to the same object.
  - This is not the same thing as comparing if the two object(s) referred to by the references represent the same value of the class in question
- To test for equality, the designer of the class typically codes an equals instance method for the class:
  - For the Counter class this might mean whether the val fields are equal
```
public boolean equals(Counter otherCounter) {return val == otherCounter.val;}
				
```
  - For the Name class this might mean whether the first and last name fields are equal:
```
public boolean equals(Name otherName) {return this.first.equals(otherName.first) && this.last.equals(otherName.last);}
				
```
```
public boolean equals(Name otherName) {return first.equals(otherName.first) && last.equals(otherName.last);}
				
```
  - The method name equals is more than a 'good' suggestion; later we will understand why it should (must?) be named .
The null value
The value null in Java is a literal representing the absence of a reference.. When assigned to a reference variable it signals that the variables is not pointing at any object.
```
BankAccount ba = null;
```
- Reference variables are often initialized to null indicating they have not yet been assigned a reference to an object.
- null may be assigned to a reference variable of any type (i.e., any class or array type).
- Attempting to invoke a method on, or access a data element from null results in a NullPointerException being thrown.
```
BankAccount ba = null;
ba.deposit(100);	// results in NullPointerException
		
```
  - This is one of the most common exceptions that occur in Java code
- Objects that are instance variables are initialized to null in the absence of any explicit initialization:
```
class SomeClass {
	…
	private String s;	// s is initialized to null
		
```
- This 'absence of reference' is often used to indicate 'failure' or 'unsucessful operation
  - for example, when searching for an object in an array, the search method would typically return null if the object does not appear inthe array.
Reading in Objects
We're going to introduce a simple and opinionated technique for reading in objects from a text file. It will also give us an opportunity to use the keyword static for the first time in a context we can explain.
- By opinionated we mean that the technique is a specific approach, that requires the data be in a particular format
A read Method
The basic idea is to:
- introduced a static method — we'll call it read that accepts a Scanner and returns an object of the class for which we are writing this method
- The method will declare (local) variables corresponding to the instance variables of the class
- The method will first check that there is data remaining in the file corresponding to an object
  - if there is no more data to be read in, the method will return null
- the method will then read data into the local variables
  - We will assume for the moment that if there's the first piece of data, it's all there
- The method will then create a new object of the class, passing the local variables as arguments to the class' constructor
- Finally, the method will return a reference to the new object
```
class BankAccount {
	…
	static BankAccount read(Scanner scanner) {
		if (!scanner.hasNextInt()) return null;		
		
		int id = scanner.nextInt();		
		int balance = scanner.nextInt();

		return new BankAccount(id, balance);
	}
	…
	private int id;
	private int balance;
}
```
Notes
- the read method creates and object from input, upon entry to the method, no such object yet exists.
  - As such the method is not invoked with a receiver, rather the desired object will be returned as the return value of the method
  - A method without a receiver is declared static
    - The way to think of this is that there is no receiving object context inside the method, thus there are no instance variables to access; or in other words the method is 'self-contained' or static, i.e., no instance variables can affect its execution.
- The first thing the method does is look to see if there is an int next in the Scanner (for the id)
  - if not, null is returned
- data is read into the locals; one per instance variable
- create the object and return it
Using the read Method
We can now read in objects using this method:
```
BankAccount ba = BankAccount.read(scanner);
while (ba != null) {
	System.out.println(ba);
	ba = BankAccount.read(scanner);
```
Notes
- read in objects in a loop until a null is returned
Files Used in This Lecture

CISC 3115 Modern Programming Techniques Lecture 1 Classes I — The Basics

Overview

In the Absence of Classes: 1115-Like Apps

A Baseline, Generic 1115-like App (App)

Modelling 'Things': A Bank Account (01-BankAccount)

Borrowing from Above

Another Sort of 'Thing': A Fuel Tank

Moving Related Methods to their Own Source Files; Separate Compilation

Two 'Things' in the Same App

Let's Add One more Layer: An Array of BankAccounts

Classes: Overview From 10,000 Feet

Classes: The Details

Introduction

Revisiting 'Some Things to Think About'

Terminology

Responsibility-Driven Programming

Data Access

Class Definition

Example: Defining a Class

Classes as Types

Objects (Instances)

Creating Instances (Objects) of a Class

Example: Using a Class

The main Method as App

Primitive Types and Reference Types

References, Objects, Aliases

Object Initialization

Constructors — Initializing Objects

Default Constructors

Constructors with Arguments

Constructor Overloading

Constructor Overloading and this

The Names of the Constructor Parameters

Overloaded Constructors

Leveraged Constructors

Default Constructor

Copy Constructor

The toString Method

== and the equals Method

The null value

Reading in Objects

A read Method

Using the read Method

Files Used in This Lecture

CISC 3115
Modern Programming Techniques
Lecture 1
Classes I — The Basics

A Baseline, Generic 1115-like App (`App`)

Modelling 'Things': A Bank Account (`01-BankAccount`)

The `main` Method as App

`Constructors` — Initializing Objects

Constructor Overloading and `this`

The `toString` Method

`==` and the `equals` Method

The `null` value

A `read` Method

Using the `read` Method