CISC 3115 — Lecture 3 — Classes Part II

CISC 3115
Modern Programming Techniques
Lecture 3
Classes Part II

Terminology

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

Responsibility-Driven Programming

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

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

Data Access

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

public — entity is accessible to all
private — entity is accessible only to objects of the class
package-protected — entity is accessible to others in the same package
- we'll address this later

Class Definition

Basic syntax

class classname {
	methods

	variables
}

Example: Defining a Class

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

	private String first, last;					// State
}

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

	private int val = 0;					// State
}

Within the body of an instance method, we are in some sense in the world of the class, i.e., we can simply refer to the instance variables of the class
- We will discuss this below in more detail in the section on scope.
Within the body of a method of the class, you can access the private variables of the class

Classes as Types

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

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

Objects (Instances)

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

Creating (Instances) of a Class

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

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

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

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

Example: Using a Class

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

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

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

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

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

	System.out.println(c);
}

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

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

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

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

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

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

The `main` Method

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

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

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

Primitive Types and Reference Types

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

References, Objects, Aliases

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

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

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

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

`Constructors` - Initializing Objects

After new creates the object it invokes a method, known as a constructor to initialize the object
The constructor is automatically invoked by new-- the programmer does not call it directly.
The constructor is named after the class (as you can see above)
```
Counter() {val = 0;}
		
```

Default Constructors

The above constructor above took no arguments
- Constructors with no arguments are known as default constructors
- Default constructors are good for simple creation of an object
  - They allow a user without much knowledge of the class to create objects of the class with little effort.

Constructors with Arguments

Constructors can also have arguments

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

Constructor Overloading

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

For example, for the following Counter class, one might want to be able to create a counter with an initial value, or simply create a counter whose value defaults to 0.
```
class Counter {
	…
	private int val;	// value of the counter
}
		
```
- In the latter case, one could use a default constructor:
```
Counter c1 = new Counter();
				
```
  while the former case would be:
```
Counter c2 = new Counter(10);			// create a Counter instance with an initial value of 10
				
```
The straightforward way to do this is to have each constructor perform the initialization on its own:
```
Counter(int v) {val = v;}
Counter() {val = 0;}
		
```

Constructor Overloading and `this`

An alternative is to have as much of initialization occur in one of the constructors and allow the other constructor(s) to call it supplying any necessary data:
```
Counter(int v) {val = v;}
Counter() {this(0);}
		
```
- The keyword this is a reference to the current object (i.e., the receiver).
- In the case of constructor overloading, we use this to specify that we are calling another constructor from the current constructor.
  - Note how the two constructors differ in signature (i.e., parameter lists), and thus when we write this(0), it is clear to the compiler that we are invoking a different constructor (the one that accepts an int parm).
- We will encounter other uses of this later on.

The `toString` Method

Most classes have a method named toString defined by their designers.

The purpose of this method is to produce and return a string representation of the class.
The signature of the method is public String toString()

`==` and the `equals` Method

Again:
- reference variables contain references to objects (or null in the absence of such a reference)
- primitive variables contain the actual values they operate on
for primitive types, the == operator compares the primitive values, which is the correct semantics; i.e., i == 4, d == 12.4
for reference types, the == operator also compares the values, however, in this case, it's a reference so we are effectively comparing if the two value (references) refer to the same object.
- This is not the same thing as comparing if the two object(s) referred to by the references represent the same value of the class in question
To test for equality, the designer of the class typically codes an equals instance method for the class:
- For the Counter class this might mean whether the val fields are equal
```
public boolean equals(Counter otherCounter) {return val == otherCounter.val;}
				
```
- For the Name class this might mean whether the first and last name fields are equal:
```
public boolean equals(Name otherName) {return this.first.equals(otherName.first) && this.last.equals(otherName.last);}
				
```
```
public boolean equals(Name otherName) {return first.equals(otherName.first) && last.equals(otherName.last);}
				
```
- The method name equals is more than a 'good' suggestion; later we will understand why it should (must?) be named .

Adding a `main` Method

A main method is often added to a class whose execution will either 'show-off' the behavior of the class, or test the class (basically the same thing).

public class Counter {
	public Counter() {val = 0;}		
	
	public void up() {val++;}
	public void down() {val--;}
	public int get() {return val;}
	
	public String toString() {return val+"";}	// The String concat, '+', converts integers to String automatically
	
	private int val;
	
	public static void main(String [] args) {
		Counter c = new Counter();
		System.out.println("After initialization: " + c.get());
		System.out.println("After initialization, using toString()" + c.toString());
		// The String concat, '+', calls an object's toString automatically
		System.out.println("After initialization, using toString() implicitly" + c);
		
		System.out.println("going up!");
		for (int i = 0; i < 10; i++) {
			c.up();
			System.out.println("The counter after " + i + " up(s) is now: " + c);
		}
		
		System.out.println("down we go!");
		for (int i = 0; i < 10; i++) {
			c.down();
			System.out.println("The counter after " + i + " down(s) is now: " + c);
		}
	}
}

More often than not, this illustrative main is placed in its own class:

class CounterApp {
	public static void main(String [] args) {
		Counter c = new Counter();
		System.out.println("After initialization: " + c.get());
		System.out.println("After initialization, using toString()" + c.toString());
		// The String concat, '+', calls an object's toString automatically
		System.out.println("After initialization, using toString() implicitly" + c);
		
		System.out.println("going up!");
		for (int i = 0; i < 10; i++) {
			c.up();
			System.out.println("The counter after " + i + " up(s) is now: " + c);
		}
		
		System.out.println("down we go!");
		for (int i = 0; i < 10; i++) {
			c.down();
			System.out.println("The counter after " + i + " down(s) is now: " + c);
		}
	}
}

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 Color Class

Simple Color class
Abstracting "real-world" classes
- real 'colors'?
- real 'windows'?
'public' keyword
- On class
- On method/constructor
- On instance variable
Source file naming and 'public'
'High' vs 'low' semantic methods
- 'Low': getRed/setRed
- 'High': darker

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

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

An `Array` Class

Ability to 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.

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