I Think You Should Register To Vote Or Check Your Registration At vote.org!

Roadmap

• Today, references for insight into how Java programs behave
  • New model of program memory and execution
  • Sort of high-level, so let it wash over you for now
• Wednesday & Friday, lists. (Sort of a non-sequitur.)
• Next week, nodes.
  • Making references a bit more concrete at this point

Variables, Before

A variable is like a "box" inside of which a piece of data is placed.

Variables, Now

A variable is a named portion of memory that contains data of a particular type and has a fixed size.

• For primitive types, data can be stored directly inside of a variable.
• For object or reference types, data is stored in a separate portion of the computer's memory. Instead of storing the data directly, variables of these types tell us how to find the data elsewhere!

Let's drill down.

Data Types in Java

Primitive Data Types

• byte, short, int, long, float, double, boolean, char
• Primitive types variable works like a box that can store a single value
• Example: int num = 42;
  

Data Types in Java

References

• Reference variables do not store simple values directly!
• Reference variables store a reference to some object
  • Literally: an address that describes where the object is stored in the computer's memory.
• The object that the reference refers to is known as its pointee

Why Make the Distinction?

All variables have the same fixed size.*

• Primitive types have a fixed "size" that fits inside of a single variable. For example, all int values can be expressed using bits (ones and zeroes)
• Objects & Records can be huge, consisting of multiple primitive & object values! They couldn't possibly be squeezed into any fixed size container.

*This is only a little bit of a lie

An "Employee" Class

Two instance variables, name and salary, along with a simple constructor. (Assume setters & getters written beneath).

public class Employee { 
	private String name; 
	private int salary; 
	public Employee(String name,  int salary) {  
		this.name = name; 
		this.salary = salary; 
	}
	... // getters & setters, too...
}

A Picture of the Reference

If we create a new ob Employee empRef = new Employee("John", 1000); we can represent the memory abstractly with the following diagram

Rules for Drawing References

1. Variables are always drawn as boxes with names outside of the boxes.
   1. Variables that store primitive types are drawn as boxes that contain the values directly.
   2. Variables that store reference (object) types are drawn as boxes that contain arrows representing references.
2. References are drawn as arrows from variables to object data.
3. Object data is drawn as a box containing the fields (instance variables) for the object.
   1. Instance variables that store reference types will feature arrows to other object data.
4. A null value is represented as a box with a line crossed through it, or by the word null.

Drawing More References

public class Employee { 
    private String name; 
    private int salary; 
    public Employee(String name,  int salary) {  
	    this.name = name; 
	    this.salary = salary; 
    }
}

public class Department {
    private Employee chair;
    private String deptName;
    public Department(String newDeptName, Employee newChair) {
        deptName = newDeptName;
        chair = newChair;
    }
}

Drawing More References

Draw the memory diagram after the following program is executed:

String name = "Lomax";
Employee l = new Employee(name, 300);
int salary = 200;
Employee s = new Employee("Stoner", salary);

Drawing More References

Draw the memory diagram after the following program is executed:

String name = "Lomax";
Employee empRef = new Employee(name, 300);
Department deptRef = new Department("English", empRef);

Dereferencing

• Accessing the value of the pointee for some reference variable
  • Variables storing primitive types cannot be dereferenced—why?
• Is done with the dot operator (.) to access a field or method of an object
• Symbolically, this is like following the arrow stored in a reference variable to the object data it points to.

Dereferencing

String myName = empRef.getName() dereferences empRef to call the getName method for that object

Referencing & null

A reference must be assigned a pointee before dereference operations will work.

• Not assigning a pointee to a reference will cause a NullPointerException when attempting to dereference.
• null: special reference value that encodes the idea of "pointing to nothing”, which is also the initial value of references

Dereferencing null

Reference Assignments

An assignment of one reference variable to another makes them the same pointee

Employee empRef = new Employee(“john”, 1000);
Employee second = empRef;
second == empRef; // true!

Reference Assignments, Visualized

Aliasing

Two references which both refer to a single pointee are said to be aliasing

• "empRef is an alias for second" or "second is an alias for empRef"

Shallow and Deep Copying

Shallow copy (of a reference) is achieved through aliasing

Deep copy creates a new copy of the pointee that has an identical structure but exists at a different location in memory.

Shallow and Deep Copying Example

Shallow copy: copies only the reference

Employee second = empRef;

Deep copy: constructs a new object and copies the values of the other object's instance variables.

Employee deepCopy = new Employee(empRef.getName(), empRef.getSalary());

Shallow and Deep Copies

Employee empRef = new Employee("John", 1000);
Employee second = empRef;
String johnName = empRef.getName();
int johnSalary = empRef.getSalary();
Employee deepCopy = new Employee(johnName, johnSalary);

Shallow and Deep Copying Example, Visualized

Referential & Structural Equality

Double equals (==) checks if two reference variables are referencing the same object (referential equality)

• Returns true for shallow copies
• Returns false for deep copies

An equals method checks if the values (data fields) of the two objects are the same (structural equality)

• Returns true for shallow copies
• Returns true for deep copies
• You have to write this yourself for your own objects.

Example equals()

public class Employee { 
	private String name; 
	private int salary; 
	public Employee(String name,  int salary) {  
		this.name = name; 
		this.salary = salary; 
	}

	public boolean equals(Employee emp) {  
		if(this == emp)
		return true;
		else{
		return this.name == emp.name &&    
				this.salary == emp.salary; 
		}
	}
}