The article (and the correct pass-by-reference litmus test) swaps the values of the variables as the caller sees them, using operations inside the swap routine.
Your example swapped the contents of the pointed-to objects, but did not change the values of the variables a1 and a2.
If you want to see the difference, assign a1 to a new variable a3 before the a1/a2 swap call. A real pass by reference swap will end up with a3 == a2, and your example ends up with a3 == a1.
May I invite you to write some code and see for yourself? Here:
C++ Swap (what you and the article call the litmus test): https://gist.github.com/anonymous/06b9251a37008d158f59
Java Swap (exactly the same thing): https://gist.github.com/anonymous/d57d272579079b4e9ee8
These programs don't only output the exact same thing, they do exactly the same thing (except the differences I noted above, about the default copy assignment operator being implicit in C++, and about C++ putting the temp variable on the stack instead of the heap).
> May I invite you to write some code and see for yourself?
Sure. I've fixed your examples so they are analogous to each other and added the check that I described in my previous post.
C++: https://gist.github.com/anonymous/9c66999844afcab15eeb Java: https://gist.github.com/anonymous/bac324b3f3c13f263e14
Look at the article. It contains c++ code for a swap litmus test. It doesn't look like your "fix". Your swap is not the traditional swap(a,b) method/function called for by the author.
Here is a traditional swap function: http://www.cplusplus.com/reference/algorithm/swap/
The C++ version I posted shows you exactly what the Java object model is doing, except since you can't take in references to the variables (Java has no pass-by-reference), you can't do the pass-by-reference swap. The only swap you can do in Java is the pass-by-value swap.
The C++ pass-by-value swap (using pointers like Java requires) looks like this:
https://gist.github.com/anonymous/73ccac277baee8841470
Note that this now prints "Fake pass-by-value swap" like the Java version.
There is no way to write a Java version that prints "Real pass-by-reference swap".
I've proved that you can write "swap" in Java. This behavior is in all important ways equivalent to the basic, traditional C++ swap, even though Java passes references by value and C++ passes by reference. You're arguing, "Yeah but look, they look different! If you put the exact same comparison code afterward, they return different things!" Well... yeah... that's because Java and C++ are different! Apples and oranges. That has nothing to do with whether the ability to write "swap" is a good litmus test.
The article says you cannot write "swap" in Java, therefore Java doesn't have pass-by-reference. I'm saying "yes, you can write 'swap' in Java.. but still Java doesn't have pass-by-reference.. so it's a bad litmus test." And you're saying "Yeah but your swap looks different." And I'm saying "No shit, that's because Java doesn't have pass-by-reference." The article didn't say the litmus test is "can you write swap in a way that looks exactly like this C++ code?".
That's it for me, I'm bowing out!
A valid, real "swap" in Java is one that passes my example code and prints "real pass-by-reference swap" and not "fake pass-by-value swap'.
T=A*
A*&