Example. A puzzling question

[comp1110-1P]
  • Liam O'Connor, Fabian Muehlboeck

Without running this program, try to deduce what it will output:

void fun1(int[] arr) { arr[0] = 100; } void fun2(int[] arr) { arr = new int[]{5,4,3,2,1}; } void fun3(int i) { i = 200; } void main() { int[] arr = new int[]{1,2,3,4,5,6}; int i = arr[0]; fun1(arr); IO.println(arr[0]); IO.println(i); fun2(arr); IO.println(arr[0]); IO.println(i); fun3(i); IO.println(arr[0]); IO.println(i); }

You will only get the answer correct if you understand what happens in Java when values are passed to functions.

Context

    Understanding reference types

    [comp1110-1U]
    • Liam O'Connor, Fabian Muehlboeck

    Example. A puzzling question

    [comp1110-1P]
    • Liam O'Connor, Fabian Muehlboeck

    Without running this program, try to deduce what it will output:

    void fun1(int[] arr) { arr[0] = 100; } void fun2(int[] arr) { arr = new int[]{5,4,3,2,1}; } void fun3(int i) { i = 200; } void main() { int[] arr = new int[]{1,2,3,4,5,6}; int i = arr[0]; fun1(arr); IO.println(arr[0]); IO.println(i); fun2(arr); IO.println(arr[0]); IO.println(i); fun3(i); IO.println(arr[0]); IO.println(i); }

    You will only get the answer correct if you understand what happens in Java when values are passed to functions.

    Definition. Passing by value (or copy)

    [comp1110-1R]
    • Liam O'Connor, Fabian Muehlboeck

    A function's variables, including its parameters, are local to that invocation of the function. When we invoke a function, some memory is set aside for a frame: storage space for the local variables in the function. The values of the arguments given in the function invocation are copied into the function's frame. This is called pass by value. When the function returns, the frame is no longer needed and destroyed.

    This is why the function fun3 has no effect on its arguments in example Example [comp1110-1P].

    Definition. Value types and reference types

    [comp1110-1Q]
    • Liam O'Connor

    Variables of type int and char (for example) are called value types. This means that a variable declared of type, say int:

    int x;

    Will contain a value, a single integer. When left uninitialised as above, they are initialised to a default value of 0.

    By contrast, array types like int[] and char[] are what's called reference types. This means that a variable declared of an array type will not contain the array data itself, but instead will contain the location in memory where the data may be found. This location is called a reference or pointer.

    Any type name that begins with a capital letter (e.g. String) is also a reference type. This is why Strings should not be compared with == — it would compare locations, not contents.

    Definition [comp1110-1Q] combined with Definition [comp1110-1R] tells us that when we call a function like fun1 or fun2 in Example [comp1110-1P], the array data itself is not copied into the function's frame, but instead just the reference is. When fun1 or fun2 are called, the variable arr in their frame has the same value as the variable arr in the frame of main — they both point to the same array. This means that when we call fun1, the contents of the array in main are observably changed, as the array indexing arr[0] follows the same pointer that is in main.

    When we call fun2, however, nothing changes in the function main, because we don't follow the pointers, but instead just change the value of the local variable arr to point to a new array, then immediately discard it.

    The Waterloo Java Visualizer

    [comp1110-1S]
    • Liam O'Connor

    The Waterloo Java Visualizer is a great way to visualise what's going on in these examples. Here's a link to Example [comp1110-1P] being visualised in it. Click "forward" to step through the program's execution.

    Note that it doesn't support Java 25, so I had to include some cruft that Java 25 has since made obsolete like (a method-free) class, public static etc. We will learn about these things later in the course but they are not relevant for now.

    Reference vs. Value Equality

    [comp1110-1T]
    • Liam O'Connor, Fabian Muehlboeck

    The difference between value types and reference types explains the differences between == and other methods to decide equality.

    For value types, == happens to capture regular equality - for example, there are no two int values that represent the number 32 but are somehow different.

    On the other hand, for reference types, == describes reference equality, identifying whether two references point to the same object in memory. Since there may be two different objects representing the same value, == is too strict in many cases. We have seen this for String equality and Array equality. It is the same way in general for objects of arbitrary classes, except that for those, by default, no other notion of equality comparison exists. We'll see later how to define our own equality comparison.

    Finally, Enums are a special case: they are a reference type, but with a guarantee that each case of a Enum refers to the same object in memory. As such, comparing the references to Enum values using == is fine - as for ints, there are no two distinct values representing the same case.

    Backlinks

      Definition. Passing by value (or copy)

      [comp1110-1R]
      • Liam O'Connor, Fabian Muehlboeck

      A function's variables, including its parameters, are local to that invocation of the function. When we invoke a function, some memory is set aside for a frame: storage space for the local variables in the function. The values of the arguments given in the function invocation are copied into the function's frame. This is called pass by value. When the function returns, the frame is no longer needed and destroyed.

      This is why the function fun3 has no effect on its arguments in example Example [comp1110-1P].

      The Waterloo Java Visualizer

      [comp1110-1S]
      • Liam O'Connor

      The Waterloo Java Visualizer is a great way to visualise what's going on in these examples. Here's a link to Example [comp1110-1P] being visualised in it. Click "forward" to step through the program's execution.

      Note that it doesn't support Java 25, so I had to include some cruft that Java 25 has since made obsolete like (a method-free) class, public static etc. We will learn about these things later in the course but they are not relevant for now.

      Understanding reference types

      [comp1110-1U]
      • Liam O'Connor, Fabian Muehlboeck

      Example. A puzzling question

      [comp1110-1P]
      • Liam O'Connor, Fabian Muehlboeck

      Without running this program, try to deduce what it will output:

      void fun1(int[] arr) { arr[0] = 100; } void fun2(int[] arr) { arr = new int[]{5,4,3,2,1}; } void fun3(int i) { i = 200; } void main() { int[] arr = new int[]{1,2,3,4,5,6}; int i = arr[0]; fun1(arr); IO.println(arr[0]); IO.println(i); fun2(arr); IO.println(arr[0]); IO.println(i); fun3(i); IO.println(arr[0]); IO.println(i); }

      You will only get the answer correct if you understand what happens in Java when values are passed to functions.

      Definition. Passing by value (or copy)

      [comp1110-1R]
      • Liam O'Connor, Fabian Muehlboeck

      A function's variables, including its parameters, are local to that invocation of the function. When we invoke a function, some memory is set aside for a frame: storage space for the local variables in the function. The values of the arguments given in the function invocation are copied into the function's frame. This is called pass by value. When the function returns, the frame is no longer needed and destroyed.

      This is why the function fun3 has no effect on its arguments in example Example [comp1110-1P].

      Definition. Value types and reference types

      [comp1110-1Q]
      • Liam O'Connor

      Variables of type int and char (for example) are called value types. This means that a variable declared of type, say int:

      int x;

      Will contain a value, a single integer. When left uninitialised as above, they are initialised to a default value of 0.

      By contrast, array types like int[] and char[] are what's called reference types. This means that a variable declared of an array type will not contain the array data itself, but instead will contain the location in memory where the data may be found. This location is called a reference or pointer.

      Any type name that begins with a capital letter (e.g. String) is also a reference type. This is why Strings should not be compared with == — it would compare locations, not contents.

      Definition [comp1110-1Q] combined with Definition [comp1110-1R] tells us that when we call a function like fun1 or fun2 in Example [comp1110-1P], the array data itself is not copied into the function's frame, but instead just the reference is. When fun1 or fun2 are called, the variable arr in their frame has the same value as the variable arr in the frame of main — they both point to the same array. This means that when we call fun1, the contents of the array in main are observably changed, as the array indexing arr[0] follows the same pointer that is in main.

      When we call fun2, however, nothing changes in the function main, because we don't follow the pointers, but instead just change the value of the local variable arr to point to a new array, then immediately discard it.

      The Waterloo Java Visualizer

      [comp1110-1S]
      • Liam O'Connor

      The Waterloo Java Visualizer is a great way to visualise what's going on in these examples. Here's a link to Example [comp1110-1P] being visualised in it. Click "forward" to step through the program's execution.

      Note that it doesn't support Java 25, so I had to include some cruft that Java 25 has since made obsolete like (a method-free) class, public static etc. We will learn about these things later in the course but they are not relevant for now.

      Reference vs. Value Equality

      [comp1110-1T]
      • Liam O'Connor, Fabian Muehlboeck

      The difference between value types and reference types explains the differences between == and other methods to decide equality.

      For value types, == happens to capture regular equality - for example, there are no two int values that represent the number 32 but are somehow different.

      On the other hand, for reference types, == describes reference equality, identifying whether two references point to the same object in memory. Since there may be two different objects representing the same value, == is too strict in many cases. We have seen this for String equality and Array equality. It is the same way in general for objects of arbitrary classes, except that for those, by default, no other notion of equality comparison exists. We'll see later how to define our own equality comparison.

      Finally, Enums are a special case: they are a reference type, but with a guarantee that each case of a Enum refers to the same object in memory. As such, comparing the references to Enum values using == is fine - as for ints, there are no two distinct values representing the same case.

      bars magnifying-glass caret-down plus minus arrow-right xmark