Call by Value vs. Call by Reference vs. Call by Sharing

Question

I'm trying to understand parameter passing in Java. There are some answers on Stackoverflow but they are not clear. The Evaluation Strategy page is very technical, so I don't understand it. This answer is helpful, but I don't understand the implications: Is Java “pass-by-reference” or “pass-by-value”?

I understand the Java uses Call by Sharing, but I'm not sure how its different from Call by Reference. I'm not sure if this is correct, can you check my answers?

Shared Steps
1) The main program calls a method and passes it an argument.
2) The expression in the argument is evaluated and its type is determined. The result is assigned to the Argument variable.

Call by Value

3) Without regard for type, a COPY of the Argument's VALUE is made and passed to the method.
4) The Formal Argument receives a variable containing a COPY of the Argument.
5) The Formal Argument makes changes to the copy.
6) The Actual Argument is UNCHANGED.

Call by Reference
3) Without regard for type, a COPY of the Argument's ADDRESS is made and passed to the method. 4) The Formal Argument receives an REFERENCE to the memory location of the Argument.
5) The Formal Argument and Actual Argument point to the same value. Both can modify the Value/Object.
6) The Method can mutate the Formal Argument WITHOUT LIMITATION. When the method ends, these changes will be seen in the Argument.

Call by Sharing (Java)
3) Without regard for type, a COPY of the Argument's ADDRESS is made and passed to the method.
4) ?
5) ?
6) ?

I know there is a difference between how Java treats primitive types and objects in parameter passing, can someone fill in these blanks by explaining why?

Answer 1

Call by Value means

• the argument is evaluated before the method is called
• the method receives a copy of the result of this evaluation
• changes that are applied to the formal argument by the method are not visible to the caller

Call by Reference means

• the argument is evaluated before the method is called
• the method receives a reference to the result of this evaluation
• changes that are applied to the formal argument by the method are visible to the caller

For now, I will skip Call by Sharing, since it does not have a clear meaning.

How it works in Java

• the argument is evaluated before the method is called
• the method receives a copy of the result of this evaluation
• changes that are applied to the formal argument by the method are not visible to the caller

As you see, Java matches the Call by Value case. However, to really understand this, you have to understand how Java handles references. To do so, consider this class

public class Foo {
    private String value;

    public Foo(String value) {
        this.value = value;
    }

    public String get() {
        return value;
    }

    public void set(String value) {
        this.value = value;
    }
}

and this code snippet:

Foo actual = new Foo("foo");      // 1
                                  // 2
Foo formal = actual;              // 3
    formal.set("bar");            // 4
                                  // 5
actual.get(); // returns "bar"    // 6

As you can see, the changes to the object in formal have been applied to the object in actual, because formal points at the same object as actual. The assignment Foo formal = actual; did copy the reference, it did not copy the object.

Now, lets have a look at another code example:

Foo actual = new Foo("foo");      // 1
                                  // 2
Foo formal = actual;              // 3
    formal = new Foo("bar");      // 4
                                  // 5
actual.get(); // returns "foo"    // 6

As you can see, the changes to formal have not been applied to actual, because the reference in formal that points at the object in actual has been overwritten by a reference to a new object. The assignment Foo formal = actual; did copy the reference, it did not copy a pointer to actual.

Now, I talked about assignments, because I think this is perfectly clear for assignments. The point is now, that this is the exact same behavior for method calls: When the method is called, the evaluated actual argument is assigned to the formal argument, see line 3. However, the formal argument is not assigned back to the actual argument after the method is done, see line 5.

The reason why this is called Call by Sharing is, that you don't pass a deep copy of the actual argument. Thus, objects are shared between the caller and the callee. If an object contains mutable state, like Foo, then all changes that are applied to that mutable state in the method are visible to the caller. Please note the difference: Changes to the passed objects are visible, changing the reference target of the formal argument is not visible.

Lastly, a quick note about primitives: The code above does not need to be changed for primitives. This means, only the type Foo would be changed to e.g. boolean. Everything else is the same. Thus, the behavior is again the same as it is for an assignment: The value is copied. Since primitive values cannot contain mutable state, it is out of question that this is Call by Value.

Answer 2

My of understanding Call By Sharing is this:

With Value types, the actual value is directly copied, and the new copy is passed to the callee. The original value cannot be modified.

With Reference types, the actual reference to the value is copied, and the new copy is passed to the callee. The referenced object can be modified, but a re-allocation will not modify the original reference.

If you reallocate using the passed reference, you are creating a new object in the callee, and a return to the caller will reflect the originally-passed object. The object created in the callee should go out-of-scope and be marked for collection.