Weird. It's pass by ref for objects and pass by value for primitives. Why the flame war?
If it were pass by ref, you could make a parameter point to a different object and it would still be visible after the method had returned.
It's like the Java equivalent of airplane-on-a-treadmill.
function f(x, y) { x = y }
a = new A()
b = new A()
assert(a != b)
f(a, b)
if (a == b) {
print('pass by reference')
} else {
print('pass by value')
}There's a correct answer to airplane-on-a-treadmill too, but that doesn't mean it's not an argument about semantics. Please let's just stop this here before this thread becomes like that other thread.
So if in java you decided to create an assign method (cuz remember operators are evil in java) and overrode equals then you could create such a situation in which it would return pass by reference.
Plus the equals operator in java is kind of f'ed anyways as it is.
Conversely if the language was pass by value (or not retarded) then code such as this should work.
function f(x, y) { x == y }
a = new String("foo");
b = new String("f").append("oo");
assert(a != b)
if (f(a, b)) {
print('pass by value')
} else {
print('pass by reference')
}There is a difference between passing an object by reference and passing the reference of the object by value. In the first case caller and callee share the same pointer to the same object while in the latter case each have a different pointer to the same object.
This article explains it very well : http://javadude.com/articles/passbyvalue.htm
It's references all the way down!
To take it to a lower level, we're passing a string of binary digits to the function. This happens either through a register, or through the stack. The function then has to decide what to do with it - either it uses it as the value of something, or it takes it as a memory address and derefences it. It can then repeat this last step for as many levels of indirection as it wishes.
It's clearer in C.
void f(struct object a); // Pass struct by value void f_(struct object* a); // Pass struct by reference, pass reference by value void f__(struct object a); // Pass reference to struct by reference, pass reference to reference to struct by value void f________struct object a); // What the hell are you doing? You've created a monstrosity
Edit: I've never used Java that much. My experience with passing things to functions/methods is primarily in C++. When I say primitive types, I mean char or int.