Java Pass by value understanding

Question

I think I understand that it is a copy of the object/data member passed into the method tricky(), as only the value is what matters, not the actual object itself. But the print statements assure me that arg1 and arg2, the copies, are indeed switched within the method. I don't understand why this wouldn't relay the information back to original objects, consequently switching them; Seeing as the method is able to successfully access the arg1.x and arg1.y data members within the method.

// This class demonstrates the way Java passes arguments by first copying an existing
// object/data member. This is called passing by value. the copy then points(refers)
// to the real object

// get the point class from abstract window toolkit
import java.awt.*;

public class passByValue {


static void tricky(Point arg1, Point arg2){

  arg1.x = 100;
  arg1.y = 100;
  System.out.println("Arg1: " + arg1.x + arg1.y);
  System.out.println("Arg2: " + arg2.x + arg2.y);

  Point temp = arg1;
  arg1 = arg2;
  arg2 = temp;
  System.out.println("Arg1: " + arg1.x + arg1.y);
  System.out.println("Arg2: " + arg2.x + arg2.y);
}




public static void main(String [] args){

  Point pnt1 = new Point(0,0);
  Point pnt2 = new Point(0,0);
  System.out.println("X1: " + pnt1.x + " Y1: " +pnt1.y); 
  System.out.println("X2: " + pnt2.x + " Y2: " +pnt2.y);
  System.out.println(" ");
  tricky(pnt1,pnt2);
  System.out.println("X1: " + pnt1.x + " Y1:" + pnt1.y); 
  System.out.println("X2: " + pnt2.x + " Y2: " +pnt2.y);  

}
}

Answer 1

The object reference is copied, and the copied reference still points to the same object in memory. This is why you can change the object using the copied reference. However, modifying the parameter references modifies the copies, not the original references. This is why redirecting the references within the method doesn't redirect the references you passed in.

Hope this clears things up.

Answer 2

Java does pass by value, but what it passes is the value of the object's reference, which gives the effect of pass by reference (for primitives, it behaves more like pass by value).

But Java is always pass by value.

Answer 3

Java is pass by value, but when we pass an object reference, the reference value is getting pass to the method, and from there the method can change the value of object members.

Look at following code:

public class Passbyvalue {

    public static void main(String[] args) {
        // TODO code application logic here
        Animal animal=new Animal();
        animal.name="Dog";
        System.out.println(animal.name);
        testIt(animal);
        System.out.println(animal.name);
    }


    public static void testIt(Animal animal){
        animal.name="Cat";
    }

}

Output

Dog Cat

This is because both reference( Original and method) are pointing to same object.

    __________
   |          |                 
   |          |<------------- Orignal Reference 
   | Object   |   
   |          |<------------- Method Reference
   |          |
   |__________|

If you want to see this effect more clearly create new object in method

public class Passbyvalue {

    public static void main(String[] args) {
        Animal animal=new Animal();
        animal.name="Dog";
        System.out.println(animal.name);
        testIt(animal);
        System.out.println(animal.name);
    }


    public static void testIt(Animal animal){
        animal=new Animal();
        animal.name="Cat";
    }

}

Output: Dog Dog

Now the method reference is posting to the other Object in heap.

Answer 4

Initially you new up both objects, which prints the following:

X1: 0 Y1: 0
X2: 0 Y2: 0

When you call tricky() you're passing in the reference to pnt1 and pnt2 by value and assigning those to arg1 and arg2. So you're passing in the location in memory. Then you print the values:

Arg1: 100100
Arg2: 00
Arg1: 00
Arg2: 100100

When you do the swap using temp, you're swapping addresses. So back in your main method pnt1 and pnt2 still hold the original address. So when you print you get:

X1: 100 Y1:100
X2: 0 Y2: 0

Here's a related thread with some additional background.

Answer 5

I used to explain this using a "graphical approach", so I hope it helps. In main, before calling tricky method you have:

pnt1 -> Point(x=0; y=0)
pnt2 -> Point(x=0; y=0)

Inside tricky method, arg1 and arg2 are copies of the pnt1 and pnt2 references respectively, so they are pointing to the same objects:

pnt1 -> Point(x=0; y=0) <- arg1
pnt2 -> Point(x=0; y=0) <- arg2

Through arg1 reference, you are modifying the first Point object:

pnt1 -> Point(x=100; y=100) <- arg1
pnt2 -> Point(x=0; y=0) <- arg2

Then, you are "pointing" the temp reference to the first Point(100;100) object. After that, you make arg1 point to the same object that arg2 is referring to -Point(0,0)-, and make arg2 point to the same object already pointed by temp, i.e., Point(100;100). Therefore, inside tricky method you swapped the memory addresses arg1 and arg2 were referring to.

pnt1 -> Point(x=100; y=100) <- arg2 (temp also pointing this object)
pnt2 -> Point(x=0; y=0) <- arg1

But once the method is finished, arg1 and arg2 (and temp) are out of scope (dissapear) and you have again:

pnt1 -> Point(x=0; y=0)
pnt2 -> Point(x=0; y=0)

with pnt1 and pnt2 unchanged as expected, given that all changes inside tricky method are performed on arg1 and arg2, that were only copies of references.

Hence, inside tricky you can change the object's contents (you have a reference to it), but you can't modify the original reference to it, as you only have a copy of it. So Java is pass by value (actually references passed by value).