Section 4.2 Reference Variables
Consider the following JShell session. The variable
k1 is initialized to 12 and k2 to 13. After the assignment k1 = k2, k1 gets the new value 13.jshell> int k1 = 12; // Declare and init k1 and k2
...> int k2 = 13;
k1 ==> 12
k2 ==> 13
jshell> k1 = k2; // Assign k1 to k2
...> System.out.println(k1); // k1 has copy of k2 value
k1 ==> 13
13
// Declare and init sb1 and sb2
jshell> StringBuilder sb1 = new StringBuilder();
...> StringBuilder sb2 = new StringBuilder();
...> sb1.append("Hello"); // Append Strings to sb1 and sb2
...> sb2.append("Goodbye");
sb1 ==>
sb2 ==>
$7 ==> Hello
$8 ==> Goodbye
jshell> sb1 = sb2; // Assign sb1 to sb2
...> System.out.println(sb1.toString());
sb1 ==> Goodbye // sb1 seems to have sb2 value
Goodbye
jshell> sb1.append(" friend"); // Append to sb1
$9 ==> Goodbye friend
jshell> sb2; // Somehow, sb2 got the
sb2 ==> Goodbye friend // appended value
jshell>
Following this, the two StringBuilder variables
sb1 and sb2 are declared and initialized to two StringBuilder objects. The String "Hello" is appended to sb1 and "Goodbye" is appended to sb2. Afterwards, we perform the assignment sb1 = sb2 and the value of sb1 is now "Goodbye". That is what we expect.Next, we append the String " friend" to
sb1 and print sb2. Somehow, the StringBuilder sb2 also got the additional String " friend". Why?The assignment operator copies values from one memory location to another. If we could look at memory we’d see the value
12 at the k1 location and 13 at the k2 location. What would we see at the sb1 and sb2 locations? It would not be the StringBuilder objects. Instead, we’d see an address indicating where Java chose to store each StringBuilder object. Said differently, the data stored at the sb1 and sb2 memory locations is the address of the StringBuilder objects, not the objects themselves. To access the StringBuilder objects stored in memory, we would have to read the address and move to that memory location first.When we performed the assignment
sb1 = sb2 the object itself was not copied. Rather, the value of the address was copied. Nothing happened to the two StringBuilder objects (yet). Both sb1 and sb2 now hold the address for where to find the second StringBuilder object. After the assignment, we have no variables remaining that store the address of the first StringBuilder and two variables that store the address of the second StringBuilder. In a very real sense, we’ve lost track of the first StringBuilder object.The dot-operator can be thought of as the mechanism that performs the dereference operation for us. Think of the dot-operator as the way we read an address from a variable and move to the memory location indicated by the address, where the object is stored. Because both
sb1 and sb2 now hold the address of the second StringBuilder object, using the dot-operator on either variable would dereference to the same object in memory. In the above example, this is why printing the String value of sb2 results in the output Goodbye friend, and not only Goodbye. Both sb1 and sb2 now reference the same object. Anything done using sb1 is visible using sb2, and vice versa.To disconnect a variable from a memory address without assigning it to another object, assign to the reference variable the special keyword null. The null keyword in Java represents the absence of an object. Indeed, when an object variable is declared but not initialized, it has the value of null. See the following JShell session. The variable
sb3 has the value null.jshell> StringBuilder sb3; sb3 ==> null jshell>
Figure 4.2.1 is another animated example that demonstrates what happens when reference variables are reassigned. Click the image to advance the animation and compare the program statements to the illustration of what is happening in memory.
Java provides no way to explicitly delete an object from a memory. So what happens to an object when there are no variables holding a reference to it? Does it just consume memory with no way to access it? In other words, does it leak memory?
