How to explain shallow-copy in Java versus pass by value?

Question

From what I understand with Java, everything is pass by value. However, when you begin talking about objects which contain other objects things get a bit interesting and i'd like to be able to communicate this better and make sure I fully understand as well. So my take here is that only the primitives within the object are actually copied, on the other hand any objects it contains...the values of those objects are not copied, rather only are copies of those references.

So if we had some object with these members

public class SomeObject {
   private String name;
   private String address;
   private  List<String> friends;

   public SomeObject(String name, String address, List<String> friends) {
      this.name = name;
      this.address = address;
      this.friends = friends;
   }
}

And we did this:

List<String> friendsList = new ArrayList<String>();
        friendsList.add("bob");
        friendsList.add("joe");

        SomeObject so1 = new SomeObject("mike", "123 street", friendsList);

        friendsList.add("zoe");
        friendsList.add("rick");
        SomeObject so2 = new SomeObject("david", "300 ave", friendsList);

        System.out.println(so1.getName() + " " + so1.getAddress());
        for (String friend : so1.getFriends()) {
            System.out.println(friend);
        }

        System.out.println(so2.getName() + " " + so2.getAddress());
        for (String friend : so2.getFriends()) {
            System.out.println(friend);
        }

Our output is this:

mike 123 street
bob
joe
zoe
rick
david 300 ave
bob
joe
zoe
rick

Even though we have created 2 separate objects, they both maintain a reference to the original friendslist. This is why I get a bit tripped up when people say Java is always pass by value.

Answer 1

The reference is passed by value, so the pointer to the list is copied, not the list itself.

Answer 2

The reference to the list is passed by value, not the list itself, meaning, you cannot change friendsList from within the constructor of SomeObject, but you may change the content it points to.

For example, if the constructor was like this:

public SomeObject(String name, String address, List<String> friends) {
    this.name = name;
    this.address = address;
    this.friends = friends;
    friends = new ArrayList<String>();
}

You will still get the same output although you assigned new list to friends.

Answer 3

Java is passing always parameters by values. In your case the object reference is passed by value. See this article that explain how and why.

http://javadude.com/articles/passbyvalue.htm

Answer 4

I've heard Java's memory model described as passing "value by reference." Any "primitive" types (int, e.g.) are passed by value. Anything that extends Object is also passed by value... but the value of an object is a reference to its location in the heap.

Answer 5

Java is pass by value. The thing is just, that what you called an object is in reality a reference to an object. The value of which was passed..

Answer 6

Everything is passed by value but an object itself is NEVER passed. Just its reference is passed, by value.

Think about objects as stored in a sort of warehouse, for every object you have an identifier that states where the object is. Ok, now wherever you pass an object from a method to another you just pass the identifier.

Answer 7

What is passed by value is the reference to the list, not the list itself. If you know little C++, than it's similar to copying the pointer of the list. The 2 objects have 2 different references that reference the SAME list. That's the explanation for this output.

Answer 8

In the following varInt holds the value "2"

int varInt = 2; 

And varObj in the following holds the value "which happens to be the reference" to the new object:

Object varObj = new Object(); 

So, if you call methods as follows -

someVar.method1(varInt); // the value 2 is passed here

someVar.method2(varObj); // the value which is the reference is passed here

So Java is always Pass-By-Value.

Answer 9

Java is not pass by value. Only primitives are passed by value, objects are passed by reference. Since you use the same list for both friend lists, the friends are the same as well.

Answer 10

Only primitives in Java are passed by value, objects and arrays are by reference.