CISC 3115 — Lecture 2

CISC 3115
Modern Programming Techniques
Lecture 4
Classes III: Class Variables and Method, Scoping, Arrays and Classes, Mutability

`static` — Class Members

Class Variables

We've seen that we have occasion to want a single copy of a variable for the entire class (rather than an instance variable that is created for each object we create).

Our example was Point.ORIGIN
- When a class variable represents a constant, we typically declare it static final`
- Because this value is shared by all instances, only one copy is needed for the entire class
We also mentioned such 'per-class' variables such as Color.RED, Color.BLACK for a Color class

we now explore this in more detail.

The keyword static specifies that the declared variable is a class variable i.e., a single copy exists for the entire class.

Accessing this variable from within the class is done in an unqualified manner: e.g. ORIGIN
Accessing it from outside the class (assuming of course that it's declared public is done by qualifying it with the class' name; e.g. Point.ORIGIN
You can also qualify it using this inside the class and a receiver outside the class, but as this is confusing (it makes it look as if it might be an instance variable) this is discouraged
A variable would be associated with the class (rather than a particular instance) for the following reasons:
- The variable is a class-wide value, usually shared by all instances of the class
  - This value is typically a constant; often an object of the class itself
    - Color class' predefined color constants
```
static final Color BLACK = new Color(0, 0, 0);
								
```
    - Calendar class' month names
```
static final int 
	JANUARY = 1,
	FEBRUARY = 2,
	…
	DECEMBER = 12;
								
```
- The semantics of the variable is class-wide; it maintains class-wide behavior:
  - Classical examples of this are instance id's: account numbers, employee id's:
```
class Employee {
	Employee(String name) {
		this.name = name;
		this.id = nextId;
		nextId++;
	}
	…
	String name;				// instance variable
	int id;					// instance variable - individual Employee's id
	static int nextId=1001;		// class variable - next id to be assigned;
}
						
```
  - also instance counting:
```
class C {
	C() {
		…
		instancesCreated++;
	}
	…
	static int instancesCreated = 0;
}
						
```
    - instancesCreated belongs to the class, not to any one object.

Class Methods

Like class variables, class methods are associated with the class as a whole rather than individual instances, and use the keyword static to indicate them as such
Unlike instance methods, class methods do not operate on a particular object
Class methods have no implicit receiver; they are invoked through the class name rather than through an object
- Inside a class method, there is no this reference.
- Therefore, class methods cannot directly access instance variables or instance methods.
A method would have no receiver for any of the following reasons:
- There is no logical receiver for the method
  - Since primitive types are not objects, they cannot serve as the receiver of a method. Operations on primitives must therefore be implemented as class methods, with the primitive supplied as an argument.
    - e.g., Math class' abs method
  - The main method is invoked by the runtime environment, not by an object.
  - A method whose goal is to create an object (i.e., there's no object yet to act as the receiver)
    - Such methods are often called factory methods
    - A read method for a class-- reads data, and uses it to call new, invoking constructor with the data.
```
static Point read(Scanner scanner) {
	int x = scanner.nextInt();
	int y = scanner.nextInt();
	return new Point(x, y);
}
								
```
      The whole point of this method is to read in the data necessary to create a Point object, create the object, and return its reference
      - We place this method in the Point — again, as part of responsibility-driven programming
- The method implements class-wide behavior
  - i.e., methods that only work with class variables
```
static int getInstancesCreated() {return instancesCreated;}
						
```

Scoping Rules

scope: the places in a program where a variable can be referenced without qualification (i.e., just using the variable's name)

class C {
	void f1() {
		int i;		// local scope
		…
		System.out.println(i);
		…
	}

	void f2(int i) { 	// local scope (parameter)
		…
		System.out.println(i);
		…
	}

	void f3() {
		…
		System.out.println(i);
		…
	}

	int i;   // class scope
}

block: a sequence of statements and declarations surrounded by {}'s.
- The declarations appearing within the {}'s (i.e., within the block) are said to be local to the block.
A variable is said to be shadowed if there is a declaration of another variable with the same name within the scope of the first.
Loosely speaking, the scope of a local variable is from it's declaration to the end of the block in which it's declared, excepting those areas where it's shadowed..
Again, loosely speaking, the scope of an instance variable is the class definition, excepting those areas where it's shadowed..
- This means that when you enter a method of the class, all the instance variable's of the class are available without further qualification (i.e., without specifying a receiver).
  - The instance variables are those that belong to the receiver of the method call; for example given the call
```
Name name = new Name("Weiss", "Gerald");
name.getFirst();
						
```
    when the method getFirst is entered as a result of the call, the instance variable first is the one belonging to the receiver, i.e., the object referred to by the variable name (with the value "Gerald").
- The same is true of the class' methods: when you enter a method of the class, all of the classes instance methods are available without further qualification, i.e., you may call them without specifying a receiver.
  - and upon calling them you are still within the same original receiver
The only real shadowing we will encounter would be for a local variable shadowing an instance variable.
```
class Name {
	Name(String last, String first) {
		…
	}
	…
	String last, first;
}
		
```
To find the corresponding declaration corresponding to a variable use:
- Work outwards from the use, looking at declarations in the enclosing blocks
  - local declarations
  - parameter declarations (parameters are also considered local variables)
- If not found, look at instance variable declarations for the class

Data Access Within the Class

Within the methods of the class itself, all variable are accessible, including private

Within any method of the class, the private variables of any object of the class are also accessible.

This is true even for class methods (such as main) that don't even have their own instance variables:

class C {
	C(int val) {this.val = val;}
	…
	C add(C otherC) {
		return new C(this.val + otherC.val);		// Legal and common
	}
	…
	public String toString() {return val;}
	…
	private int val;

	public static void main(String [] args) {
		…
		C c1 = new C(10);
		c1.val = 12;		// Legal, but definitely not recommended.
	}
}

Note the situation changes if we move main out to its own app class:

class CApp {
	public static void main(String [] args) {
		…
		C c1 = new C(10), c2 = new C(12);
		//c1.val = 12;	// Here (outside the class) it's simply illegal

		C c3 = c1.add(c2);
		System.out.println(c3);		// prints 22
	}
}

Summary: Scope of Fields (Class/Instance Methods/Variables/Constants)

When using methods/variables of a class within the class itself (including main), no qualification is needed. One simply calls the methods or uses the variable.
- within an instance method of the class, all variables and methods (instance as well as class) are in scope and can thus be accessed
- within a class method of the class, only class variables and methods are in scope (since there's no receiver).
When using class methods/variables from outside the class, the class name appears where the receiver would normally appear.

Classes as Types

We can think of a class definition as defining a new data type
- The class definition specifies the values of the class as well as the acceptable behavior on those values
  - This is parallel to primitive types, such as int where the type specifies the legal values (the integers) and their operations (+, -, *, /, %).
We can then declare variables of the class type.
These variables will then refer to objects of the class.

`main` and Applications

Each class can have its own main method, even if it is not intended to be launched as an application

In such non-application contexts, main can be used as a 'demo' method, i.e., it can illustrate how the clas is used, e.g.,

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

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

	System.out.println(c);

	while (c.getVal()) != 0) 	// assuming a getter has been defined
		c.down();

	System.out.println(c);
}

However, while we can place main in side the class it is demo'ing:
```
class Counter {
	…
	public statuc void main(String [] args) {…}
}
		
```
we usually place outside in its own class:
```
class CounterApp {
	…
	public statuc void main(String [] args) {…}
}
		
```
- First, this emphasize the 'demo' nature of the method; it does not contribute behavior to the class
- Second, it prevents main from accessing private instance variables of the case (as mentioned above)

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:

Introduce a static method — we'll call it read
- read 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, we need to return that no object was created
- Java provides a null value
  - null represent the absence of an object reference
  - it can be assigned and used by any reference type
  - You can test for a refereence being equal to null:
```
Counter c;
…
if (c == null) …
						
```
  - Attempting to invoke a method with null as the receiver throws a NullPointerException
- If there is no data remaining in the file, we return null
Assuming there is still data, 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
Once data has been read into all the local variables, the method will 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

Here is an example of such a method reading in data for a BankAccount 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 the the next dataa item in the Scanner is an int (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 bankAccount = BankAccount.read(scanner);
while (bankAccount != null) {
	System.out.println(ba);
	bankAccount = BankAccount.read(scanner);

Notes

read in objects in a standard (priming the pump) while loop until a null is returned

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.

Default Initialization of Variables

local variables are not initialized by default; it is the programmer's responsibility to initialize them before use
- Attempting to use a local before initialization causes a compiler error
Instance and class variables are automatically initialized to type-specific default values when an object is created:
- 0 for integers
- 0.0 for floating point
- false for boolean
- '\0' (ASCII code 0) for char
- null for reference variables
- These defaults are typically replaced by explicit initialization at the point of declaration or within the constructor.

Another Example: A `BankAccounts` App

Assuming a BankAccount class with id and balance instance variables, and the (by now) usual toString and read methods, code an app that reads in and processes multiple bank accounts:

class BankAccount {
	BankAccount(int id) {this.id = id;}
	public void deposit(int amount) {balance += amount;}
	public void withdraw(int amount) {balance -= amount;}
	
	public int getBalance() {return balance;}
	public int getId() {return id;}

	public String toString() {return "account #"+ id + " balance: $" + balance;}

	private int balance = 0;
	private int id;
}

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;
		BankAccount [] accounts = new BankAccount[CAPACITY];
		int size = 0;

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

			BankAccount account = search(accounts, size, id);
			if (account == null) {
				account = new BankAccount(id);
				size = add(accounts, size, account, CAPACITY);
				System.out.println("Added " + account);
			}

			switch (action) {
				case "D":
					account.deposit(amount);
					System.out.println("After deposit of $" + amount + ": " + account);
					break;
				case "W":
					account.withdraw(amount);
					System.out.println("After withdrawal of $" + amount + ": " + account);
					break;
				default:
					System.out.println("*** Error *** unknown action: " + action);
			}
		}
		System.out.println();
		System.out.println("=== Accounts ===");
		print(accounts, size);
	}	

	public static BankAccount search(BankAccount [] accounts, int size, int id) {
		for (int i = 0; i < size; i++) 
			if (accounts[i].getId() == id) return accounts[i];
		return null;
	}

	public static int add(BankAccount [] accounts, int size, BankAccount account, int capacity) {
		if (size == capacity) {
			System.err.println("Capacity reached; make arrays larger");
			System.exit(1);
		}
		accounts[size] = account;
		return size+1;
	}
		
	public static void print(BankAccount [] accounts, int size) {
		for (int i = 0; i < size; i++)
			System.out.println(accounts[i].getId() + ": $" + accounts[i].getBalance());
	}

}

In order to do the search and/or print out the information for an account, we need access to the instance variables:
- We only need to get the value of balance (for printing purposes), so we introduce a getBalance method.
- We need to get the id of an account (for printing and searching) account object), so we introduce getId
In our previous BankAccounts (non-class) example, we needed to return the index of the sought-after element since we were dealing with parallel arrays. This is no longer the case … we wish to return the object being loooked for, i.e., a BankAccount.
- Returning -1 is no longer appropriate for an unsuccessful search; rather we return the special value null that represents the absence of an object.
When we come back from an unsuccessful search (i.e., we get a null back from search, we create a new BankAccount object and then add it to the array of BankAccounts.
Note that add returns the position where the new account was inserted, and that is then used as the new value of size
- This is necessary as the array and its size are local to the app's main method.
- We are also taking a risk of sorts here; while it is true that the add method does indeed insert accounts sequentially, that is not an absolute necessesity, and if the insertion occurred in a different manner, this would not work
- Had the array and size been instance variables, it would be a totally different story; that's coming soon
BankAccounts is not an object class … it has not instance variables; rather it's an application class. Further, the main logic is in main. The code is structured much like that in 1115, and thus the methods are static, i.e., the main focus with regard to the array of bank accounts are on the procedures rather than objects.

Added account #1001 balance: $0
After deposit of $200: account #1001 balance: $200
Added account #1030 balance: $0
After deposit of $100: account #1030 balance: $100
After withdrawal of $50: account #1030 balance: $50
After withdrawal of $70: account #1001 balance: $130

=== Accounts ===
1001: $130
1030: $50

Arrays of Objects

As mentioned above, a class definition introduces a new type into the system, whose name is that of the class. Just as we would with any other type, we may have occasion to declare an array of instances of a class.

Declaring an Array of Objects

Declaring an array of objects is identical to declaring an array of any other type:

int [] intArr;				
String [] stringArr;		
Name [] nameArr;
PhonebookEntry [] entries;

Even though arrays are not defined by a class definition, they are considered objects (and thus reference values).
- There several consequences of this:
  - the variable that will 'hold' an array is a reference variable
  - declaring the array reference variable does NOT create the array object (just like declaring a reference variable of a class does not create an instance)
    - Given the above declarations, trying to subscript any of the above arrays, e.g.:
```
System.out.println(intArr[0]);
				
```
      results in a NullPointerException
- None of this is new, this was all covered in 1115 with arrays of primitive types (and String)

Creating an Array of Objects

Analogous to creating an object of a class, creating an array object involves the new operator:

String [] stringArr = new String[20];	// Creates an array of 20 String references and assign the 
								//	reference to the array object to stringArr
Name [] nameArr = new Name[100];		// Creates an array of 100 Name references and assigns the 
								//	reference to the array object to nameArr

Note that in turn, the above did not create 20 String objects, or 100 Name objects, but rather 20/100 String/Name reference locations (which can then hold references to 20/100 String/Name objects)

Populating the Array with Instances of the Class

Once the array reference has been assigned a reference to an array object, the elements (which are only reference locations) of the array can be populated by creating instances of the class and assigning their references to the elements of the array:

final int CAPACITY = 100;
Name [] names = new Name[CAPACITY];

names[0] = new Name("Gerald", "Weiss");
names[1] = new Name("David", "Arnow");
names[2] = new Name("Yedidyah", "Langsam");
…

or more typically, the contents of the array would be read in from a file using a read method, which reads the data from the file, creates the object (which is initialized via the constructor being passed the data), and returns its reference:

final int CAPACITY = 100;
Name [] names = new Name[CAPACITY];
int size = 0;

Scanner scanner = new Scanner(new File("names.text"));

Name name = Name.read(scanner);		
while (name != null) {
	if (size >= CAPACITY) {
		System.out.println("Too many names in file -- increase the size of your array");
		System.exit(1);
	}
	names[size++] = name;
	name = Name.read(scanner);		
}

Recall that the read method is typically defined as a static method (because no object has been created yet), that reads the values to be passed to the constructor into local variables, then creates the object (passing those values to the constructor via the new statement) and returns the reference to the new object as the return value of the method.

Working With Arrays

Once the array has been populated, you use it as you would any other array:

void print(Name [] names, int size) {
	for (int i = 0; i < size, i++)
		System.out.println(names[i] + (i < size-1 ? ", " : ""));
}

boolean contains(Name [] names, int size, Name name) {
	for (int i = 0; i < size, i++)
		if (names[i].equals(name)) return true;
	return false;
}

Arrays as Instance Variables (Arrays in Objects)

We've seen that a class can be used as the element type of an array. We can also have an array be an instance variable of an object.

class FootballTeam {
	…
	private Player [] offensiveSquad = new Player[11];
	private Player [] defensiveSquad = new Player[11];
	private Player [] specialSquad = new Player[3];
}

class Arr {
	…
	private int [] arr = new int[100];
	private int size = 0;
}

From a `BankAccountsApp` to a `BankAccounts` Class

We now restructure our application that worked with an array of bank accounts into a true object class that has an array of bank accounts as an instance variable.

The `BankAccounts` Class

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

class BankAccounts {
	public BankAccount search(int id) {
		for (int i = 0; i < size; i++) 
			if (accounts[i].getId() == id) return accounts[i];
		return null;
	}

	public void add(BankAccount account) {
		if (size == CAPACITY) {
			System.err.println("Capacity reached; make arrays larger");
			System.exit(1);
		}
		accounts[size] = account;
		size++;
	}
		
	public String toString() {
		String result = "";
		for (int i = 0; i < size; i++)
			result += accounts[i] + "\n";
		return result;
	}

	private static final int CAPACITY = 100;
	private BankAccount [] accounts = new BankAccount[CAPACITY];
	private int size = 0;
}

We've moved the array and its associated size variable into the class
The methods dealing with the array, i.e., search and add have much simpler signatures now that they have a receiving object (the BankAccounts object).
The problem with passing size around is no longer relevant; it's an instance variable and thus accessible to all the instance methods of the class
Notice the static in the declaration of CAPACITY
The print of the previous app can now be turned into a toString

The App

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"));

		BankAccounts accounts = new BankAccounts();

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

			BankAccount account = accounts.find(id);
			if (account == null) {
				account = new BankAccount();
				account.setId(id);
				accounts.add(account);
				System.out.println("Added " + account);
			}

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

The app no longer has to worry about maintaining the size variable
A minor aside … the accounts variable is now BankAccounts ref variable; in the previews implementation it was an array ref variable.

Another Example: A Phonebook (`Phonebook`)

Given the file, "phonebook.text" containing phone entries in the format last-name phone-number, write an application that allows the user to look up a phone number via the last name. You can assume no two entries have the same last name.

An Overview

This example requires an array (container) of objects comprising the multiple entries of a phonebook. What follows is a standard way of structuring and implementing such a situation. The will be three classes:

A PhonebookEntry class that will model the entry, i.e., a name and number
A Phonebook class. This will model the collection of entries and will essentially be a partially-populated array.
- PhonebookEntry is the element type of the array
The PhonebookApp class. As with the earlier app classes in this lecture, this app class will illustrate use of the Phonebook object.

`PhonebookEntry`

class PhonebookEntry {
	PhonebookEntry(String name, String number) {
		this.name = name;
		this.number = number;
	}

	String getName() {return name;}
	String getNumber() {return number;}

	public String toString() {return name + ": " + number;}

	public static PhonebookEntry read(Scanner scanner) {
		if (!scanner.hasNext()) return null;
		String name = scanner.next();
		String number = scanner.next();
		return new PhonebookEntry(name, number);
	}

	String name;
	String number;
}

not much of note; nothing new here … we've got some instance variables, their corresponding getter methods, and a toString
- We've added getter's because we will need them for the Phonebook class
  - How we know this is a matter of expoeirence
  - Alternatively, we could have waited until we designed the Phonebook class and then come back and add them (remember, true class design is an iterative process)
This is a simple class modelling a simple object with a couple of attributes and provides the element type of our phonebook proper
Note the read method … it follows the logic outlined above

`Phonebook`

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

public class Phonebook {
	public static Phonebook read(Scanner scanner)  {
		Phonebook phonebook = new Phonebook();
		PhonebookEntry entry = PhonebookEntry.read(scanner);
		while (entry != null) {
			phonebook.add(entry);
			entry = PhonebookEntry.read(scanner);
		}
		return phonebook;
	}

	public void add(PhonebookEntry entry) {
		if (size == CAPACITY) {
			System.out.println("Phonebook capacity exceeded - increase size of underlying array");
			System.exit(1);
		}
		entries[size] = entry;
		size++;
	}

	public String lookup(String name) {
		for (int i = 0; i < size; i++)
			if (entries[i].getName().equals(name)) return entries[i].getNumber();
		return null;
	}

	public String toString() {
		String result = "{";
		for (int i = 0; i < size; i++)
			result += entries[i].getName() + ":" + entries[i].getNumber() + (i < size-1 ? ", " : "");
		result += "}";
		return result;
	}

	private static final int CAPACITY = 100;
	private PhonebookEntry [] entries = new PhonebookEntry[CAPACITY];
	private int size = 0;
}

There are no values that need to be initialized when the object is created; they all can be (and are) specified as initializations at the point of declarations of the instance variables
- Were we to write a constructor it would
  - be a default constructor since it requires no arguments, and
  - contain no logic (its all in the declarations)
```
Phonebook() {} // nothing to do
					
```
- Under such circumstances, the class designed can omit the constructor
We place the read method here as we are populating the phonebook and a general rule is to place methods in the class they operate on (are responsible for).
- There are some enhancements we could make, but they involve a bit more familiarity with designing classes; so we'll stick with this approach, it's simple and intuitive
The read method reads in PhonebookeEntry objects by delegating that task to the PhonebookEntry class THe task of this read method is to then add the entry to the phonebook via the add method..
The add method performs the insertion of the entry into the array instance variable (we call it the underlying array or container)
The lookup method iterates through the array, comparing the name again the name being searched for and if found, returns the corresponding number. If the number cant be found, it returns the value null.
- This is why we needed getters in the entry class.
- Again, null is the value representing the lack of a reference to an object. It is assigned to a variable that is currently not referencing anything. It is often used as a 'failure' value for searches in the same sense that -1, i.e., representing a non-existent value.
- Why not act like find and return the position in the array?
The toString method leverages the toString of the PhonebookEntry
Again, notice the comma-logic in toString

`PhonebookApp`

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

public class PhonebookApp {
	public static void main(String [] args) throws Exception {
		final String FILENAME = "phonebook.text";

		Scanner scanner = new Scanner(new File(FILENAME));

		Phonebook phonebook = Phonebook.read(scanner);

		System.out.println(phonebook);
		System.out.println();

		Scanner keyboard = new Scanner(System.in);

		System.out.print("name? ");
		while (keyboard.hasNext()) {
			String name = keyboard.next();
			String number = phonebook.lookup(name);
			if (number != null) 
				System.out.println(name + ": " + number);
			else
				System.out.println(name + ": *** not found");
			System.out.print("name? ");
		}
	}
}

even though there's no explicit (default) constructor, we still create the object in the usual fashion.
notice the printing of the phone book right after the read; that's more so that we can show use the toString of Phonebook.
Finally, notice the overall elegance of our implementation; the code is minimal and quite readable.
- the movement to class (eliminating all those arguments/parameters), together with breaking the app up into three classes, really streamlines things, and provides a 'template' for other apps of this sort.

Sample Test Run

Arnow       123-456-7890
Harrow      234-567-8901
Jones       345-678-9012
Augenstein  456-789-0123
Sokol       567-890-1234
Tenenbaum   678-901-2345
Weiss       789-012-3456
Cox         890-123-4567
Langsam     901-234-5678
Thurm       012-345-6789

Here is a sample execution of the program.
User input is in bold.

{Arnow:123-456-7890, Harrow:234-567-8901, Jones:345-678-9012, Augenstein:456-789-0123, Sokol:567-890-1234, Tenenbaum:678-901-2345, Weiss:789-012-3456, Cox:890-123-4567, Langsam:901-234-5678, Thurm:012-345-6789}

name? Weiss
Weiss: 789-012-3456
name? Arnow
Arnow: 123-456-7890
name? Washington
Washington: *** not found
name? Jones
Jones: 345-678-9012
name? Thrum
Thrum: *** not found
name? Thurm
Thurm: 012-345-6789
name?

An `Array` Class

We'll now present a more 'complete' class that operates like an array. Create a class that encapsulates (contains as private data and thus protects) the data needed to maintain an array:

The array itself
A size field

This is our first example of a container or collection class.

We lose some things by moving from an array to a class:

No more subscripting — method calls only
Can only do it for one type (for the moment)

We gain quite a bit, though

We don't have to pass an array and a size around — they're embedded in the Array instance.
Later, we'll add logic to this class to allow instances to resize their (internal) array as needed.

Modelling Things with Several (Logically-Related) Elements: A Container (`02-Container`)

Write an app that reads values from a file and places them into a container, i.e., a data entity that contains other items of data. The methods to be provided are:

add — adds a value to the container
find — searches the container for a value and returns the location at which the value was found and -1 otherwise
get — returns the value at a specified position in the container
size — returns the number of elements in the container
isEmpty — returns true if the container has no elements; false otherwise
toString — returns a string-representation of the container with surrounding {}'s and commas between the elements

class Container {
	public int add(int value) {
		values[size] = value;
		size++;
		return size;
	}

	public int size() {return size;}

	public boolean isEmpty() {return size() == 0;}

	public int find(int value) {
		for (int i = 0; i < size; i++)
			if (values[i] == value) return i;
		return -1;
	}

	public int get(int index) {return values[index];}

	public String toString() {
		String result = "{";
		for (int i = 0; i < size; i++)
			result += values[i] + (i < size-1 ? ", " : "");
		return result + "}";
	}
	
	private static final int CAPACITY = 100;
	private int [] values = new int[CAPACITY];
	private int size = 0;
}

Notes

The container has a capacity (CAPACITY) as well as a size (size)
- The capacity is sometimes knows as the physical size and the size as the logical size
Notice that in add we must return the new value of size (because of call-by-value), yet the contents of the values array does indeed change (the new element is in the array upon returning from the method.
- This is NOT an example of call-by-reference; we are still working with call-by-value. For an explanation, see the discussions on References and Arrays and Methods in my 1115 lecture notes on Arrays
Notice the definition of isEmpty in terms of size.
- This is an example of a delegation or wrapper method
We did NOT handle the situation of an out-of-bound index sent to get
We also did NOT handle the situation of container overflow/
Note the comma-logic used in the print to properly place the commas
- THis is an example of not-last-time logic

Summary

values and size work hand-in-hand to realize the container
- They are both needed for the container to have any integrity.
- They need to be passed in tandem to just about nay method dealing with the container
Again, multiple containers is cumbersome and you have to make sure that you never mix up the values array and size variable of two different containers.

Notes

Note how the array and size instance variables work in concert with each other
And again, note the signatures of the class' methods; they correspond much more closely to the operation on a container (i.e., add a value rather than add a value to the array containing 'size' elements
As before, in order to eliminate magic numbers in the code proper, we declare a constant (final) named CAPACITY, initialize it to the capacity (physical size) to be used for all array instance variables, and use it exclusively wherever the capacity value is required
- However, we do not need (or want) a CAPACITY variable created with every instance we created (they're all going to contain 100), so we declare it static, (lacking change) — which means only one CAPACITY variable is created and shared by the entire class (i.e., all instances).
  - Such variables are known as class variables (or static), as they operate at the class (rather than instance) level
- This is somewhat similar to the notion of static in method headers. There also, static meant that the method is not tied to any particular set of instance variables
- We declared CAPACITY to be private as we have decided that it is nobody's business what the capacity of the array is. Were we to decide differently, we have a couple of choices:
  - Make CAPACITY public
    - To access this variable from outside the class, one would write Container.CAPACITY
  - Keep it private and introduce a method named getCapacity (thus an outside caller can obtain the value, but not modify it).
    - Since this method is limited to accessing the value of CAPACITY — a static variable, it is also declared static as it does not access or interact with instance variables.
    - To call this method from outside the class, one would write Container.getCapacity()

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

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

		Container container = new Container();

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

			switch (action) {
				case "A":
					value = scanner.nextInt();
					container.add(value); 
					System.out.print("After adding " + value + ": " + container);
					break;

				case "F":
					value = scanner.nextInt();
					int pos = container.find(value);
					if (pos >= 0) 
						System.out.println(value + " is at position " + pos + " of the container");
					else
						System.out.println(value + " is not in the container");
					break;

				case "G":
					index = scanner.nextInt();
					value = container.get(index);
					System.out.println("The value at location " + index + " is " + value);
					break;

				default:
					System.out.println("*** Error *** unknown action: " + action);
			}
		}
	}	
}

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.
- Points model points, lines model lines
- Counters model counters, upper-bounded counters should use counter and add the upper bound logic

Basic Class Design

Look for the 'nouns' in the problem specification-- those are the classes
Try to select the 'primary' class
Try to come up with a user scenario for each class, i.e., how a user might want to interact with the class
- Provides the methods (behavior)
Look for what must be information maintained between method invocations, or in order to implement a method
- Provides the instance variables

A Taxonomy of Classes

Application Classes
- Contain main
- Orchestrate program execution
- Coordinate other classes
- Typically not reusable
Domain (Object) Classes
- Model entities in the problem domain
- Contain state and behavior
- Instantiated as objects
- Examples: Point, BankAccount, Person
Utility Classes
- Contain only static methods (and possibly constants)
- Not instantiated
- Provide general-purpose operations
- Examples: Math, helper classes

Nested Classes and Static Nested Classes

A way to hide a (typically helper) class from the outside world

class Phonebook {
	static class PhonebookEntry {
		…
	}
	…
}

Mutable vs Immutable Classes

Some classes are deliberately designed so that their objects — once initialized — cannot be modified

Such a class is called an immutable class
This is in contrast with a mutable class whose objects can be modified

The operations in an immutable class always produce a new object of the class (rather than modifying one of the operands
- This is similar to the simple arithmetic operations, e.g., a + b, the result of the operation is a new value
- Such operations are called pure (or as we said immutable);
The operations of a mutable class typically modify the receiver
- This corresponds to the compound assignment operations, e.g., a += b, the result of the operation is stored in the left operand
- Such operations are calleded in-place

Immutable Classes

class ImmutableColor {
	public ImmutableColor(int r, int g, int b) {
		this.r = r;
		this.g = g;
		this.b = b;
	}
	…
	public ImmutableColor lighter() {
		if (r < 255 && g < 255 && b < 255) 
			return new ImmutableColor(r+1, g+1, b+1)
		else
			return null;	
	}

	private final int r, g, b;
}

Notes

Notice the final in the declaration of the instance variables. This is because they will not be modified once initialized in the constructor.
- final variables do not need to be initialized at point of declaration; they can be given their initial (and only) value within the constructor.
Notice the method creates a new Color object (rather than modifying the receiver).
- This is the essence of the immutability property.
The method returns null if the color cannot be made lighter
- Alternatively, an exception could be thrown; we'll address that approach in the next lecture (on exception-handling)

Mutable Classes

class MutableColor {
	public MutableColor(int r, int g, int b) {
		this.r = r;
		this.g = g;
		this.b = b;
	}
	…
	public MutableColor makeLighter() {
		if (r < 255 && g < 255 && b < 255)  {
			r++;
			g++;
			b++
			return this;
		}
		else
			return null;	
	}

	private int r, g, b;
}

Notes

Notice the change in the method name (makeLighter) to better reflect the semantics of the method
Notice even though the method operates in-place on the receiver, it still returns a value — the receiver itself
- This is to allow chaining.
```
MutableColor color = new MutableColor(100, 34, 67);
System.out.print(color.makelighter().makeLighter().makeMoreTransparent();
		
```

Criteria for Mutability/Immutability

Immutable: when an object is aliased by many variable, each expecting it's value to remain unchanged unless it alone makes the modification
- example: String
Mutable: when changes to an object should be reflected among all aliases
- example: containers
- note that there is a need for immutable containers as well, i.e., when the container takes part in a modification operations (e.g., adding an element) a new copy of the container is made, and the element added to it, the original remains untouched, and the copy becomes the result of the operation.

CISC 3115 Modern Programming Techniques Lecture 4 Classes III: Class Variables and Method, Scoping, Arrays and Classes, Mutability

static — Class Members

Class Variables

Class Methods

Scoping Rules

Data Access Within the Class

Summary: Scope of Fields (Class/Instance Methods/Variables/Constants)

Classes as Types

main and Applications

Reading in Objects

A read Method

Using the read Method

The null value

Default Initialization of Variables

Another Example: A BankAccounts App

Arrays of Objects

Declaring an Array of Objects

Creating an Array of Objects

Populating the Array with Instances of the Class

Working With Arrays

Arrays as Instance Variables (Arrays in Objects)

From a BankAccountsApp to a BankAccounts Class

The BankAccounts Class

The App

Another Example: A Phonebook (Phonebook)

An Overview

PhonebookEntry

Phonebook

PhonebookApp

An Array Class

Modelling Things with Several (Logically-Related) Elements: A Container (02-Container)

Summary

Responsibility-Driven Programming

Basic Class Design

A Taxonomy of Classes

Nested Classes and Static Nested Classes

Mutable vs Immutable Classes

Immutable Classes

Mutable Classes

Criteria for Mutability/Immutability

Files Used in This Lecture

CISC 3115
Modern Programming Techniques
Lecture 4
Classes III: Class Variables and Method, Scoping, Arrays and Classes, Mutability

`static` — Class Members

`main` and Applications

A `read` Method

Using the `read` Method

The `null` value

Another Example: A `BankAccounts` App

From a `BankAccountsApp` to a `BankAccounts` Class

The `BankAccounts` Class

Another Example: A Phonebook (`Phonebook`)

`PhonebookEntry`

`Phonebook`

`PhonebookApp`

An `Array` Class

Modelling Things with Several (Logically-Related) Elements: A Container (`02-Container`)