CISC 3115 — Lecture 3 — Classes Part II

CISC 3115
Modern Programming Techniques
Lecture 1
Classes — Composition, Arrays & Containers, Mutability

Overview

Revisiting Constructors: A `Point` Class

We will now illustrate a variety of class-related concepts and techniques, using a set of related classes: points, lines, and pairs of lines. Here is some documentation reviewing those concepts: Some supporting documentation … and here is a quick synopsis of the most relevant ideas:

Points and Quadrants
- A two-dimensional (2D) point is represented by an x-coordinate and a y-coordinate representing a horizontal and vertical displacement from a distinguished point known as the origin whose own coordinates are 0 and 0.
- The coordinates are written a (x, y)
- Point reside on the Cartesian plan which is divided into 4 quadrants (>0, >0), <0, >0), <0, <0), >0, <0)), 4 axes (>0, 0), 0, >0), <0, 0), 0, <0)), and the origin ((0, 0)).
Lines
- A line is represented by its two endpoints
- The length of a line is the distance between the two endpoints which is calculated as the square root of the sum of the squares of the differences between their x- and y-coordinates: √((x₂-x₁)² + (y₂-y₁)²)
- The slope of a line is the ratio of change in y to x, i.e., (y₂ - y₁) / (x₂ - x₁)

Points (`Points`)

Model a point in 2-dimensional space (i.e., the 2D plane). A point is represented as a pair of values (we'll stick with integers … at least for now) representing the x and y components of the point.

The class should have the methods:

quadrant: returns a numeric value between 0 and 8 corresponding to the quadrant or axis the point lies on
quadrantStr: returns a String value corresponding to the quadrant/axis the point lies on

import java.util.Scanner;

public class Point {
	Point(int x, int y) {
		this.x = x;
		this.y = x;
	}

	public String quadrantStr() {
		switch (quadrant()) {
			case 0: return "Origin";
			case 1: return "Quadrant 1"; 
			case 2: return "Quadrant 2";
			case 3: return "Quadrant 3"; 
			case 4: return "Quadrant 4"; 
			case 5: return "Positive x axis"; 
			case 6: return "Positive y axis"; 
			case 7: return "Negative x axis"; 
			case 8: return "Negative y axis"; 
			default: return "???";
		}
	}
			
	public int quadrant() {
		if (x == 0 && y == 0) return 0;
		if (x > 0 && y > 0) return 1;
		if (x < 0 && y > 0) return 2;
		if (x < 0 && y < 0) return 3;
		if (x > 0 && y < 0) return 4;
		if (x > 0 && y == 0) return 5;
		if (x == 0 && y > 0) return 6;
		if (x < 0 && y == 0) return 7;
		if (x == 0 && y < 0) return 8;
		return -1;
	}

	public String toString() {return "(" + x + ", " + y + ")";}

	public static Point read(Scanner scanner) {
		if (!scanner.hasNextInt()) return null;
		int x = scanner.nextInt();
		int y = scanner.nextInt();
		return new Point(x, y);
	}

	private int x, y;
	public static final Point ORIGIN = new Point(0, 0); 
}

Notes

Note the need for a constructor here:
- each Point instance will have its own individual values for x and y; furthermore x and y need to be initialized with these values upon object creation, thus requiring a constructor
- Again, the constructor is only called when an object of the class is created, and is not directly called by the programmer; but rather automatically as part of the new operation. As such, it has no return type (it's not called, so doesn't doesn't have anywhere to return a value to), nor is its name a choice of the programmer (since they don't call it). As such, the name of the constructor is the name of the class; this works out well in the syntax and semantics of the constructor, as we will see.
  - Not every OOP language follows this naming convention; Python for examples does something a bit different.
- In our Point class, we need a method that accepts two integers which are then assigned to x and y; given the above naming discussion we have:
```
Point(int …, int …) {
	x = …;
	y = …;
}
				
```
  - Note the absence of a return type,and the name of the constructor method (Point).
  - Regarding the naming of the parameters, and the use of this see below
  - A point to be made: in the following code, the variables a and b are parameters to the method and thus local variables, while x and y are instance variables and declared in the class-body.
```
class Point {
	Point(int a, int b;) {
		…
	}
	…
	private int x, y;
}
						
```
  - The body of the constructor assigns the values of the parameters to the instance variables.
  - As seen below in the app, the parameters receive their values from the corresponding arguments passed to the constructor in the new expression.
```
Point p = new Point(12, 14);	// create the Point (12, 14)
						
```
Notice the call (invocation) of quadrant within quadrantStr. This is an(other) example of leveraging where we take advantage of logic in another method.
The read method follows the logic as presented in Lecture 1: we check for more data and return null if there is none; otherwise we read the values to be passed to the constructor into local variables, create the Point object passing those values, and return the reference to the newly created object.
Notice the class variable ORIGIN. We wish to have a 'well-known' / predefined object for the origin (it IS special after all), so we create an Point object corresponding to it and assign its reference to a well-named variable. There's no need for more than one such object, i.e., we don't want to have a new origin object for each instance, so we declare it static.
- This is a common technique … to declare and create 'well-known', i.e., useful objects of the class and make them class variables of the class as well.
One final comment … in the absence of a class defining a Point object; e.g. the procedural programming style of 1115, we would be passing x and y coordinates (instead of a Point object) all over the place.
- This will be come even more pronounced when we introduce the Line and LinePair classes.

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

public class PointApp {
	public static void main(String [] args) throws Exception {
		Scanner scanner = new Scanner(new File("points.data"));

		System.out.println(" --- From the file");
		System.out.println();

		while (scanner.hasNextInt()) {
			int 
				x = scanner.nextInt(),
				y = scanner.nextInt();
			doIt(x, y);
		}

		Random r = new Random(12345);

		System.out.println();
		System.out.println(" --- Some random points between (-9, -9) and (9, 9)");
		System.out.println();

		for (int i = 1; i <= 20; i++) {
			int 
				x = r.nextInt(19)-9,
				y = r.nextInt(19)-9;
			doIt(x, y);
		}
	}


	public static void doIt(int x, int y) throws Exception{
		System.out.println(x + " " + y);

		Point p =  new Point(x, y);
		System.out.println("p: " + p);

		System.out.println("Quadrant: " + p.quadrantStr() + " (" + p.quadrant() + ")");
	}
}

Notes

We illustrate the Point class with some 'well-known values' (from the file):
We then follow up with some random points for 'completeness'
- The argument to the Random objejct's nextInt call is the range of the random number generated (0 &helliop; argument); here, I chose a value that would (in conjunction with the -9 applied to the return value) produce integers in the range -9 … 9
  - The r.nextInt random number generating method returns a value between 0 and 18 (the argument minus 1). Substracting 9 gives us a value between -9 and 9.
The actual processing of the individual points is carried out by the doIt method.
- We will use this arrangement in many of our apps (i.e., a method that does most of the work and is invoked with varying data elements; we often call such a method a workhorse method).

Composition — Objects as Instance Variables

Composition is one of the two ways of building new classes from existing classes
- The other way is inhertiance, introduced later
The new class is composed of an instance variable whose type is also a class
- Of course, may be other instance variables of primitive or class type
Examples:
- Given a Name class, a Student class would contain an instance variable of type Name. (Similarly if the was an Address class)
```
class Name {
	…
}
…
class Student {
	…
	private Name name;
	private Address address;
}
				
```
- In fact, given a String class, a Name class would contain an instance variable of type String for the last name (similarly for first name).
```
class Name {
	…
	private String last, first;
}
				
```
- Given an Employee class, a Department class might contain an array of Employee objects.
  - and the Employee class probably contains a Name field
```
class Employee {
	…
	Name name;
}
…
class Department {
	…
	private Employee [] employees;
}
				
```
It's clear from the above that this nesting of one class' object(s) within another class (as an instance variable) is not limited to one level.

Consequences of Composition

Remembering the basic motto of responsibility-driven programming — 'design the class to do one thing, and have it be completely responsible for its own behavior', we define methods for manipulating and observing the object
- The methods of a class constructed using composition can then use the methods of the composed objects (i.e., the class-typed instance variables) to achieve their own behavior
  - Example:
```
class Patient {
	…
	public String toString() {
		return name + " (" + dateOfBirth + ")";
	}
	public boolean equals(Patient other) {
		return name.equals(other.name) && dateOfBirth.equals(other.dateOfBirth);
	}
	…
	private Name name;
	private Date dateOfBirth;
}
						
```

Composition & Constructors

When using composition, there is often a chaining in the constructors similar to that of toString and equals

Instance variables default to null

class Name {
	Name(String last, String first) {…}

	…

	private String last, first;

class Person {
	Person(int age, Name name) {
		this.age = age;
		this.name = name;
	}

	Person(int age, String last, String first) {this(age, new Name(last, first));}

	…

	private Name name;
	private int age;
}

`static` — Class Members

States that the variable or method is associated with the class rather than a particular object/instance of the class
- class variables and class methods
No this or instance variable (or methods) allowed
Basic idea is that there's no receiver
- That's the motivation for the static keyword — the method/variable is static, i.e., it's not dependent on any particular instance/object of the class.
There would be no receiver for any of the following reasons:
- Useful for:
  - Variables associated with class rather than instances (class-wide values that are independent of any instance)
    - Class-wide constants (used with final)
      - Color class' predefined color constants
        static final Color BLACK = new Color(0, 0, 0);
      - Calendar class' month names
        static final String JANUARY = 1, FEBRUARY = 2. … DECEMBER = 12;
    - Sequential 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;
}
								
```
  - Methods not associated with a receiver
    - Methods whose primary parm is a primitive type
      - Math class' abs method
      - Integer class' parseInt method
  - main method (called from 'nowhere'-- no receiving object)
    - and similarly, utility methods invoked from main
  - Method whose goal is to create an object (i.e., there's no object yet to act as the receiver)
    - A read method for a class-- reads data, and uses it to call new, invoking constructor with the data.

Scoping Rules

Within the methods of a class, one can access the private variables of another instance of the same class 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;
		…
		System.out.println(i);
		…
	}

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

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

	int i;
}

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

An interesting Example of Scoping Rules in Action — Another Use of `this`

Here is a variation on the Name constructor:

class Name {
	Name(String last, String first) {
		…	
	}
	String last, first;
}

Note how the parameters to the constructor shadows the instance variables

How do we write the body of Name(String last, String first) {...}?

Name(String last, String first) {
	this.last = last;
	this.first = first;
}

The keyword this specifies the receiver and this this.first is an explicit (i.e., qualified) referral to the instance variable of the class (rather than the local parameter of the same name).

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.

class C {
	C(int val) {this.val = val;}
	…
	C add f(C otherC) {
		return new(val + otherC.val C);		// 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.
	}
}

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 23
	}
}

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.

A `Counter` class

an instance variable, val containing the value of the counter
a method, up, that increments the counter's value by 1
a method, down, that decrements the counter's value by 1

class Counter {
	void up() {...}
	void down() {...}

	int val;
}

A `Window` class

an instance variable, width, that will contain the width (in pixels) of the window
an instance variable, height, that will contain the height (in pixels) of the window
an instance variable, x, that will contain the horizontal position (in pixels) of the window
an instance variable, y, that will contain the vertical position (in pixels) of the window
an instance variable, fgcolor, that will contain the text color of the window (where Color is itself a class)
an instance variable, bgcolor, that will contain the background color of the window (where Color is itself a class)
an instance variable, text, that will contain the text currently in the window
a method, move that changes the position of the window
a method, resize that changes the size of the window
a method, setFgColor that changes the text color of the window
a method, getFgColor that returns the text color of the window
a method, setBgColor that changes the background color of the window
a method, getBgColor that returns the background color of the window
a method, insert that will insert text into the window

class Window {
	void move(int newX, int newY) {...}
	void resize(int new width, int newHeight) {...}
	void setFgColor(Color newFgColor) {...}
	Color getFgColor() {...}
	void setBgColor(Color newBgColor) {...}
	Color getBgColor() {...}
	void insert(String newText, int where) {...}
	
	int width, height;
	int x, y;
	Color fgColor, bgColor;
	String text;
}

An object can thus be thought of as a programming mechanism that 'binds' data together with the methods that operate upon that data

Modelling Related and Hierarchical Things: Points, Lines & Line Pairs (`03 Points, Lines, Line Pairs`)

Lines (`Lines`)

Model a line in 2-dimensional space (i.e., the 2D plane). A line is represented as two pair of values (i.e., points)

We will support the methods:

length: returns the length of a line
isVertical: returns whether a line is vrtical (infinite slope)
slope: returns the slope of a line

public class Line {
	Line(Point endPoint1, Point endPoint2) {
		this.endPoint1 = endPoint1;
		this.endPoint2 = endPoint2;
	}

	Line(int x1, int y1, int x2, int y2) {this(new Point(x1, y1), new Point(x2,  y2));}

	public double length() {return Math.sqrt((Math.pow(endPoint1.getX() - endPoint2.getX(), 2) + Math.pow(endPoint1.getY() - endPoint2.getY(), 2)));}
	public boolean isVertical() {return endPoint1.getX() == endPoint2.getX();}
	public double slope() {return (endPoint1.getY() - endPoint2.getY()) / (double)(endPoint2.getX() - endPoint1.getX());}

	public static Line read(Scanner scanner) {
		Point p1 = Point.read(scanner);
		if (p1 == null) return null;
		Point p2 = Point.read(scanner);
		return new Line(p1, p2);
	}

	public String toString() {return endPoint1 + " - " + endPoint2;}

	private Point endPoint1, endPoint2;
}

Notes

Note the overloaded constructors; one can create a line object wither using a pair of Point objects, or by providing the x/y values for the two endpoints
- whether the second constructor is useful is really up to the designer of the class and the eventual users of the class.
There doesn't seem to be any need or application for a default constructor in this class (what would it mean to say Line line = new Line())?
To calculate the length of the line, we need the x and y values of the Point object, however, they are in accessible being declared private in that class.
- We're not about to make them public but we are willing to provide access to their values (but not the ability to modify them).
- We therefore introduce getter (or accessor) methods getX and getY providing such access.
- To do this we to go back to our Point class and add these two methods (see below)
  - Again, an alternative is to make them public but that opens the values up tp modificationm
  - There is a third alternative we'll discuss later when we talk about packages
Again, the read methods follows the usual logic, but here the values for the constructor are themselves objects (Points) rather than primitives, which will be read in using their own read method. (With primitives we used the Scanner's own methods for reading in primitives, such as int We read in the first Point — a return value of null indicates no more data and we in turn return null to our caller; otherwise we read in the second Point (we're assuming if the first Point is there, so is the second), create the Line object, and return it.
What about getEndPoint1 and getEndPoint2?



public class Point {

	…

	public int getX() {return x;}
	public int getY() {return y;}

	…

	private int x, y;
}


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

public class LineApp {
	public static void main(String [] args) throws Exception {
		Scanner scanner = new Scanner(new File("lines.data"));

		while (scanner.hasNextInt()) {
			int 
				x1 = scanner.nextInt(),
				y1 = scanner.nextInt(),
				x2 = scanner.nextInt(),
				y2 = scanner.nextInt();
			doIt(x1, y1, x2, y2);
		}
		
		Random r = new Random(12345);

		System.out.println();
		System.out.println(" --- Some random points between 0 and 9");
		System.out.println();

		for (int i = 1; i <= 20; i++) {
			int 
				x1 = r.nextInt(19)-9,
				y1 = r.nextInt(19)-9,
				x2 = r.nextInt(19)-9,
				y2 = r.nextInt(19)-9;
			doIt(x1, y1, x2, y2);
		}
	}

	public static void doIt(int x1, int y1, int x2, int y2) throws Exception {
		System.out.println(x1 + ", " + y1 + ", " + x2 + ", " + y2);

		Point p1 = new Point(x1, y1);
		Point p2 = new Point(x2, y2);
		Line line = new Line(p1, p2);

		System.out.println("p1: " + p1 + " p2: " + p2);
		System.out.println("line: " + line);

		printQuadrantInfo(p1);
		printQuadrantInfo(p2);

		System.out.println("The length of the line is: " + line.length());
		if (line.isVertical())
			System.out.println("Vertical line, no slope");
		else
			System.out.println("The slope of the line is: " + line.slope());
		System.out.println();
	}

	public static void printQuadrantInfo(Point p) {
		System.out.println(p + " Quadrant: " + p.quadrantStr() + " (" + p.quadrant() + ")");
	}
}



Notes

	We create the Line object in doIt usinf the two-argument (endpoints)
		constructor. We could have done it using the four-argument (x/y/ values) constructor:
		Line line = new Line(x1, y1, x2, y2);
		
		
			Notice, however, that doing so does not provide us with variables p1 and p2
				for the endpoints.
			
The only reason our app is able to print out quadrant info or even just the poins is because it created the
				Point objects. Had we used the four-arg constructor (where the x/y values are passed), we would not have
				access to the Point objects (created in that Line constructor.
		




Line Pairs(Line Pair)


Model a pair of lines in 2-dimensional space (i.e., the 2D plane). A pair of lines line is represented as four pair of values (i.e., two lines of two endpoints)
 

We will support the methods:


	isParallel
	
isPerpendicular




public class LinePair {
	LinePair(Line l1, Line l2) {
		line1 = l1;
		line2 = l2;
	}

	public boolean isParallel() {return line1.slope() == line2.slope();}
	public boolean isPerpendicular() {return line1.slope() == -1/line2.slope();}

	public static LinePair read(Scanner scanner) {
		Line line1 = Line.read(scanner);
		if (line1 == null) return null;
		Line line2 = Line.read(scanner);
		return new LinePair(line1, line2);
	}

	public String toString() {return "line1: " + line1 + "/" + "line2: " + line2;}

	Line line1, line2;
}



Notes

	There really is no other intuitive constructor; there would be no reason to create a 
		LinePair from anything other than two Lines (i.e, on would not 
		create a pair of lines by supplying the four endpoints or the eight x/y values)
	
The read method is completely analogous to that of Line. Note 'handing off'
		at each level to the next level down … this is another form of 'chaining', 'delegation', or 'leveraging'.



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

public class LinePairApp {
	public static void main(String [] args) throws Exception {
		Scanner scanner = new Scanner(new File("line_pairs.data"));

		while (scanner.hasNextInt()) {
			int 
				x11 = scanner.nextInt(),
				y11 = scanner.nextInt(),
				x12 = scanner.nextInt(),
				y12 = scanner.nextInt(),
		
				x21 = scanner.nextInt(),
				y21 = scanner.nextInt(),
				x22 = scanner.nextInt(),
				y22 = scanner.nextInt();
			doIt(x11, y11, x12, y12, x21, y21, x22, y22);
		}
	}
	
	public static void doIt(int x11, int y11, int x12, int y12, int x21, int y21, int x22, int y22) throws Exception {
		System.out.println("x11: " + x11 + " y11: " + y11 + " x12: " + x12 + " y12: " + y12 + " / " + 
						" x21: " + x21 + " y21: " + y21 +  "x22: " + x22 + " y22: " + y22);

		Point p1 = new Point(x11, y11);
		Point p2 = new Point(x12, y12);
		Line line1 = new Line(p1, p2);
		Point p3 = new Point(x21, y21);
		Point p4 = new Point(x22, y22);
		Line line2 = new Line(p2, p2);
		LinePair linePair = new LinePair(line1, line2);

		System.out.println("linr pair: " + linePair);

		printQuadrantInfo(p1);
		printQuadrantInfo(p2);
		printQuadrantInfo(p3);
		printQuadrantInfo(p4);

		System.out.println("The length of the first line is: " + line1.length());
		System.out.println("The length of the second line is: " + line2.length());
		double m1 = line1.slope();
		double m2 =  line2.slope();
		System.out.println("The slope of the first line is: " + m1);
		System.out.println("The slope of the second line is: " + m2);

		if (linePair.isParallel()) System.out.println("The two lines are parallel");
		else if (linePair.isPerpendicular()) System.out.println("The two lines are perpendicular");
		System.out.println();
	}

	public static void printQuadrantInfo(Point p) {
		System.out.println(p + ") Quadrant: " + p.quadrantStr() + " (" + p.quadrant() + ")");
	}
}



Notes

	Not much to say … basically same as LineApp






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

public class LinePair {
	public static void main(String [] args) throws Exception {
		Scanner scanner = new Scanner(new File("line_pairs.data"));

		while (scanner.hasNextInt()) {
			int 
				x11 = scanner.nextInt(),
				y11 = scanner.nextInt(),
				x12 = scanner.nextInt(),
				y12 = scanner.nextInt(),
		
				x21 = scanner.nextInt(),
				y21 = scanner.nextInt(),
				x22 = scanner.nextInt(),
				y22 = scanner.nextInt();
			doIt(x11, y11, x12, y12, x21, y21, x22, y22);
		}
	}
	
	public static void doIt(int x11, int y11, int x12, int y12, int x21, int y21, int x22, int y22) throws Exception {
		System.out.println("(" + x11 + ", " + y11 + ") - (" + x12 + ", " + y12 + ")" + " / " + 
						"(" + x21 + ", " + y21 + ") - (" + x22 + ", " + y22 + ")");

		printQuadrantInfo(x11, y11);
		printQuadrantInfo(x12, y12);
		printQuadrantInfo(x21, y21);
		printQuadrantInfo(x22, y22);

		System.out.println("The length of the first line is: " + length(x11, y11, x12, y12));
		System.out.println("The length of the second line is: " + length(x21, y21, x22, y22));
		double m1 = slope(x11, y11, x12, y12);
		double m2 =  slope(x21, y21, x22, y22);
		System.out.println("The slope of the first line is: " + m1);
		System.out.println("The slope of the second line is: " + m2);
		if (isParallel(x11, y11, x12, y12, x21, y21, x22, y22)) System.out.println("The two lines are parallel");
		else if (isPerpendicular(x11, y11, x12, y12, x21, y21, x22, y22)) System.out.println("The two lines are perpendicular");
		System.out.println();
	}

	public static void printQuadrantInfo(int x, int y) {
		System.out.println("(" + x + ", " + y + ") Quadrant: " + quadrantStr(x, y) + " (" + quadrant(x, y) + ")");
	}

	public static String quadrantStr(int x, int y) {
		switch (quadrant(x, y)) {
			case 0: return "Origin";
			case 1: return "Quadrant 1"; 
			case 2: return "Quadrant 2";
			case 3: return "Quadrant 3"; 
			case 4: return "Quadrant 4"; 
			case 5: return "Positive x axis"; 
			case 6: return "Positive y axis"; 
			case 7: return "Negative x axis"; 
			case 8: return "Negative y axis"; 
			default: return "???";
		}
	}
			
	public static int quadrant(int x, int y) {
		if (x == 0 && y == 0) return 0;
		if (x > 0 && y > 0) return 1;
		if (x < 0 && y > 0) return 2;
		if (x < 0 && y < 0) return 3;
		if (x > 0 && y < 0) return 4;
		if (x > 0 && y == 0) return 5;
		if (x == 0 && y > 0) return 6;
		if (x < 0 && y == 0) return 7;
		if (x == 0 && y < 0) return 8;
		return -1;
	}


	public static double length(int x1, int y1, int x2, int y2) {return Math.sqrt((Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2)));}
	public static double slope(int x1, int y1, int x2, int y2) {return (y2 - y1) / (x2 - x1);}
	public static boolean isParallel(int x11, int y11, int x12, int y12, int x21, int y21, int x22, int y22) {return slope(x11, y11, x12, y12) == slope(x21, y21, x22, y22);}
	public static boolean isPerpendicular(int x11, int y11, int x12, int y12, int x21, int y21, int x22, int y22) {return slope(x11, y11, x12, y12) == -1/slope(x21, y21, x22, y22);}
}


-->

Modelling Many Thing with Many Elements: 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 goes a step further than the previous ones in that there are two 'multiple's here: the multiple attributes of the entries of the phone book 
(name and number), and multiple entries forming the phonebook.


	The multiple attributes of an entry (name and number) will form a class we'll call PhonebookEntry
	
The multiple entries will form an array / container


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
This class will bear a striking resemblance to our Container class above. In fact, we COULD make use of that class but at this stage of our OOP knowledge it would prove to be more of a distraction than anything else
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;
}

Notes

not much of note; nothing new here … we've got some instance variables, their corresponding getter methods, and a toString
This is a simply class modelling a simple object with a couple of attributes and provides the lement type of our phonebook proper

`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;
}

Notes

There are no values that need to be initialized when the object is created; they can all be specified as initializations in the 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
- Note that our first couple of classes (Counter and Container fell into this category as well. It wasn't until Point, which required a per-instance x/y value that we needed to introduce constructors.
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 the values (name and number strings) that will be used to construct an entry in the phone book, creates the entry object with them, and inserts it into the array.
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.
- 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

`PhonebookEntry`

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

Notes

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 get to use the toString of Phonebook.
Finally, notice the overall elegance of our implementation; the code is minimal and quite readable -- a far cry from the Lecture 1 version.
- 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

For example if the file phonebook.text cntains:

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. Your program should replicate the prompts and output:

{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?

Notes

Note the use of parallel arrays
- Corresponding elements must be kept in synch

Returning to Our `BankAccounts` 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"));

		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;

			BankAccount account = find(accounts, size, id);
			if (account == null) {
				account = new BankAccount();
				account.setId(id);
				size = add(accounts, size, account, CAPACITY);
				System.out.println("Added account " + account.getId() + " with balance of " + account.getBalance());
			}

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

	public static BankAccount find(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());
	}

}

Notes

We've consolidated id and balance into a BankAccount class and replaced the pair of parallel arrays with a single array of type BankAccount.
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) as well as modify the value (as part of the initialization of the account object), so we introduce getId as well as setId methoda
Such methods are called getter/setters or accessor/mutator methods.
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.

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;
				
```
Even though arrays are not defined by a class definition, they are considered objects (and thus reference values).
- There several consequences of the above:
  - 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;
}

`BankAccounts` Once Again

The `BankAccounts` Class

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

class BankAccounts {
	public BankAccount find(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 void print(int [] ids, int [] balances, int size) {
		for (int i = 0; i < size; i++)
			System.out.println(ids[i] + ": $" + balances[i]);
	}

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

Notes

We've moved the array and its associated size variable into the class
We'll discuss the static in the declaration of CAPACITY a bit later.
- For the moment, we'll simply say that all the instances of the class have the same capacity.

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;

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

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

Notes

The app no longer has to worry about maintaining the size variable
The methods dealing with the array, i.e., find and add have much simpler signatures now that they have a receiving object (the BankAccounts object).
A minor aside … the accounts variable is now BankAccounts ref variable; in the previews implementation it was an array ref variable.

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

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

True object classes
- Application classes
- Utility classes
App classes
Static class

Inner 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.

<>Files Used in This Lecture

CISC 3115 Modern Programming Techniques Lecture 1 Classes — Composition, Arrays & Containers, Mutability

Overview

Revisiting Constructors: A Point Class

Points (Points)

Composition — Objects as Instance Variables

Consequences of Composition

Composition & Constructors

static — Class Members

Scoping Rules

An interesting Example of Scoping Rules in Action — Another Use of this

Data Access Within the Class

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

A Counter class

A Window class

Modelling Related and Hierarchical Things: Points, Lines & Line Pairs (03 Points, Lines, Line Pairs)

Lines (Lines)

Line Pairs(Line Pair)

Modelling Many Thing with Many Elements: Phonebook (Phonebook)

An Overview

PhonebookEntry

Phonebook

PhonebookEntry

Returning to Our 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)

BankAccounts Once Again

The BankAccounts Class

The App

An Array Class

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

Summary

Basic Class Design

A Taxonomy of Classes

Inner Classes

Mutable vs Immutable Classes

Immutable Classes

Mutable Classes

Criteria for Mutability/Immutability

CISC 3115
Modern Programming Techniques
Lecture 1
Classes — Composition, Arrays & Containers, Mutability

Revisiting Constructors: A `Point` Class

Points (`Points`)

`static` — Class Members

An interesting Example of Scoping Rules in Action — Another Use of `this`

A `Counter` class

A `Window` class

Modelling Related and Hierarchical Things: Points, Lines & Line Pairs (`03 Points, Lines, Line Pairs`)

Lines (`Lines`)

Line Pairs(`Line Pair`)

Modelling Many Thing with Many Elements: Phonebook (`Phonebook`)

`PhonebookEntry`

`Phonebook`

`PhonebookEntry`

Returning to Our `BankAccounts` App

`BankAccounts` Once Again

The `BankAccounts` Class

An `Array` Class

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