Clarification on the statement: "Object references are passed by values in Java"

Question

As I'm relatively new to Java, i'm still not sure about the basic pass-by-value/pass-by-reference thing. I've read this question on SO: Is Java “pass-by-reference” or “pass-by-value”?, which seems to have some very good answers. One of the articles referenced in one such answer was Java is Pass-by-Value, Dammit!.

After reading the answers, and the article, I thought:

1. Everything in Java is pass by value, there's no pass by reference (follows from the readings).
2. Primitives are always passed by value (my thought)
3. Objects are passed by reference (my thought)
4. The point above(3) is actually wrong and Object references are passed by value (follows from the article).

So now, I'm struggling between points 3 and 4. I wrote this simple class to clear things a bit:

package Chap_1;

/**
 * Created by user1 on 7/18/15.
 */
public class JavaTest1 {

    private double balance;

    public JavaTest1(double amt) {
        balance = amt;
    }

    public double getBalance() {
        return balance;
    }

    public void method1() {
        JavaTest1 obj1 = new JavaTest1(300.00);
        System.out.println("Balance in method1 before method2= " + obj1.getBalance());
        method2(obj1);
        System.out.println("Balance in method1 after method2 = " + obj1.getBalance());
    }

    public void method2(JavaTest1 o) {
        o.balance -= 100.00;
    }

    public static void main(String[] args) {
        JavaTest1 j1 = new JavaTest1(500.00);
        System.out.println("Balance in main before= " + j1.getBalance());

        j1.method1();
        System.out.println("Balance in main after = " + j1.getBalance());

    }
}

With this code, I get the output:

Balance in main before= 500.0
Balance in method1 before method2= 300.0
Balance in method1 after method2 = 200.0
Balance in main after = 500.0

My observations are:

1. In main, things get started with one JavaTest1 object j1, with a starting balance of 500. j1 then calls method1().
2. In method1(), another JavaTest1 object is created, with starting a balance of 300. method1() then calls method2().
3. In method2(), an object of type JavaTest1 is passed. This method then deducts 100 from the balance of the object reference that was passed to it.
4. When I run the code, I see that the balance of the object created in method1 is reduced to 200 in method2().

Now this is where my confusion lies. If object references are passed as values, then the balance deduction in method2() should not have modified the object created in method1(). But since it did modify the balance, doesn't it essentially say that objects are always passed as references, proving that both method1() and method2() operate on the same object. Otherwise, method2(JavaTest1 o) should have created another object of type JavaTest1 with it's reference being called o.

Answer 1

Actually this problem is simply caused by a misunderstanding of statement 3 and 4. "Objects are passed by reference" means that if an object is used as argument for a method, a reference to the object will be passed to the method - think of this reference as an int with a specific meaning. "Object references are passed by value" means that the reference itself will be passed by value. These two don't exclude each other.

Answer 2

Though objects appear to be passed by reference, the way it really works is that references to objects are passed by value. You can tell the difference if, within a function, you change a formal parameter of an object type to another object (or to null) -- the actual parameter passed by the caller won't change, in other words the caller won't see the assignment.

(If the caller were to see an assignment to a formal parameter in a called function that would be representative of pass by reference. For example, C# has out and ref parameters for these purposes.)

Answer 3

Okay, let's think this out a bit. At this line:

JavaTest1 j1 = new JavaTest1(500.00);

you create a JavTest1 object and save a reference to it (a pointer to it, essentially) in j1. The balace is 500.00 as you expect.

Then you call method1:

j1.method1();

Inside method1 you create a new JavaTest1object obj and set its balance to 300.00. Notice that this is a whole new object, with its own balance.

When you call method2 you're doing so on the object you created, obj. You subtract 100.00 from the balance, and sure enough the balance is 200.00.

You then return from that method and

System.out.println("Balance in main after = " + j1.getBalance());

prints out the balance from j1 -- *which hasn't been touched by anything and so is still 500.00.

The key here is that you have two separate objects, Call by value or reference doesn't matter, because you simply have two completely separate objects.