Discussion on: 5 years working with Java, got big surprise today with "Pass by value"

Best thing my uni did was teach me c and c++ instead of java for this reason. If you have the time, working with manual memory allocation really clears these things up. After that, for most languages with a GC the rule is pass by value for primitives, and pass by reference for everything else.
You also notice that p is really a pointer, just dressed up. When you pass p to checkPerson you are passing the pointer by value. This means the data is copied when passed, and changes to it won't affect the original. I have a more detailed explanation below but this is the short version. Thanks for sharing! I know it's hard being wrong on the internet, especially when you're more experienced but stumbled into a knowledge gap.

Long version:
So let's walk through it:

• First, a variable p is created on the stack. It is of type person but this is just java abstracting away what's really happening: p is actually a pointer (a variable which contains an address in memory) to an object of type person. Note that the new keyword is not used, and instead this pointer is set to null.
• Next, checkPerson(p) is called. Remember that p is really a pointer in the background. So its value is copied and given to the new p inside checkPerson. Notice how we are just evaluating p, whatever is returned will just be ignored.
• Now checkPerson notices that p is null, creates a new person, joe, on the heap, and sets p to joe's address. Remember that p as a pointer is really passed by value, so this is just a copy. The original p is still null. It then returns p. This doesn't come up often in java because usually your changing values or executing methods associated with p. When this happens you would follow p to the same object in heap that the calling function sees. However, in this case we are changing p, the pointer, itself.
• at this point if we had said p = check person(p) we would be in a very different universe.
• now the same thing happens, but in reverse, we create a person mary and then run check person on it. Inside check person, p is set to null, but that doesn't matter as p is passed by value.

Working with languages like c and c++, while certainly a pain at times, can really provide insight into how languages like java manage data in the background. If you have the time and are looking for an exercise, I suggest studying c data structures. Get to a point where you can implement a linked list without a reference source, without memorizing it either, and without memory leaks. Then do the same for c++ and you'll see how oop allows you to do data structures in a safer, more organised way. After that you can do the same in java, and you'll see how garbage collection prevents most memory leaks, and how it allows you to abstract away the idea of pointers without truly removing them. As a side project you can look at doing it again in c++ but using RAII (resource allocation is initialization) principals. Although that doesn't really relate to what's here, it's just a cool idea.