• Primitive (a.k.a. Atomic or Fundamental) Types:
  • Types like boolean, double, int,... that don't have constituent parts
• Reference Types:
  • Types like classes and arrays

• Primitive Types:
  • Identifier/Name
  • Primitive Value
• Reference Types:
  • Identifier/Name
  • Reference (The terms "reference", "memory address", and "pointer" are often used interchangeably. Be aware that there can be important differences.)
  • Nerd Humor
    
    (Courtesy of Dinosaur Comics)
    

• An Observation:
  • It is often convenient to differentiate a reference variable that has been initialized from one that has not
• The Reference null:
  • null can be used to indicate that a reference variable does not refer to anything

• Purpose:
  • Object "membership"
• Internally:
  • Performs address arithmetic

• In Reality:
  • Memory allocation in Java is complicated, has changed over time (e.g., from the PermGen section to the MetaSpace section), and is handled by the Java Virtual Machine (JVM) and can vary with the JVM
• For Our Purposes:
  • We will use a simpler model

• Name Table:
  • Holds information that available at compile-time (e.g., declarations of local variables, parameters, class names)
• Heap:
  • Holds information that is determined at run-time when the new operator is invoke
• Class Space:
  • Holds information about the static attributes of classes
• Literal Space:
  • To save memory, Java "interns" String literals (i.e., it stores only one copy of a specific String)

• What It Does for Objects:
  • Allocates (a contiguous block of) memory to hold all of the non-static attributes
  • Invokes the constructor (that is its right-side operand)
• What It Does for Arrays:
  • Allocates (a contiguous block of) memory to hold all of the elements
  • Initializes all of the elements
  • Assigns a value to the (final) length attribute at that address
• What It Evaluates To:
  • The address of the memory that is allocated

Note About the Heap, Literals space, and Class space: We will sometimes worry about the size of entities and work directly with the bytes and will sometimes work with larger entities and not worry about the bytes they occupy.

In this example (from a fragment of main()), the same memory is used for the variables during each iteration.

In this example (from a fragment of main()), memory is allocated for a Color object each iteration. (Reminder: A Color object has three int attributes, named red, green, and blue.)

Note: In this example we are not worrying about the size of the three int attributes in the Color objects.

• Assignment in General:
  • Assign what is on the right-hand-side of the operator to the variable on the left-hand-side
• With Value Types:
  • The left-hand-side variable contains a a value
  • The right-hand-side must be a value
• With Reference Types:
  • The left-hand-side variable contains an address
  • The right-hand-side must be an address
  • The assignment process is sometimes referred to as "binding" a particular object to a variable

• final Variables:
  • The compiler ensures that the variable can only be initialized once
• With Value Types:
  • The behavior is as expected
• With Reference Types:
  • The behavior might be surprising - a reference can only be assigned to the variable once, but values/references can be assigned to the attributes of the object being referred to multiple times

Consider the following class:

And the following fragment (in main()):

The following example (from a fragment of main()) uses the assignment operator both during the instantiation of an object and to create an alias.

In the following example (from a fragment of main()), p and q refer to the same object so changing the attributes of one changes the attributes of "the other".

• Different Situations:
  • Sometimes you want two variables to refer to the same object (i.e., aliases)
  • Sometimes you want two variables to (initially) refer to copies of the same object
• Kinds of Copies:
  • Shallow Copy - When an object has an attribute that is a reference type, only the reference is copied (i.e., the copy contains an alias of the attribute)
  • Deep Copy - When an object has an attribute that is a reference type, a (deep) copy of the attribute is made

The relational equals operator (i.e., ==) can be used with reference types, and it is sometimes necessary to do so, but you must understand that it compares two references.

• What We Just Learned:
  • When used with reference types, the == operator compares references
• Suppose We Want to Compare the Attributes:
  • Well-designed classes include a .equals() method for this purpose

String literals are reference types, but the compiler can be smart and store only one instance of each (a process called "interning").

Since String objects are reference types, a String variable can contain the reference null.

This is not the same thing as what is sometimes called the "null String" (and sometimes, perhaps less ambiguously, called the "empty String").

Consider the following example:

and recall that the Math class has two static double attributes, E and PI.

• Some Other Languages:
  • Unwanted memory needs to be deallocated (i.e., returned to the memory heap)
  • Objects need to be "destroyed" (by calling their destructor)
• Java:
  • Has a garbage collector

• Garbage and "Leaked" Memory:
  • Memory that is no longer referenced by any variable
• Garbage Collection:
  • Automatically returning garbage to the memory heap

Note that the address of c changes every iteration. Hence the memory that was allocated in the previous iteration becomes garbage.

• An Important Point:
  • Arrays are reference types (in Java)
• Questions for Another Lecture:
  • What happens in each of the following statements?
  • int[] scores;
  • scores = new int[3];
  • scores[0] = 5;
  • 
    
  • Student[] cs149;
  • cs149 = new Student[3];
  • cs149[0] = new Student("Barney","Rubble");