I have studied Java and Go so far. Passing by value / passing by reference in these two languages is organized here.

Definition in the first place

Pass by value (call by value): A method of making a new copy of the value and passing it to the argument of the method.
Pass by reference (call by reference): A method of passing a reference to the variable itself as a method argument.

For Java

Arguments to the method are passed 100% pass by value.
However, when a Java object is stored in a variable, what is stored there is a "reference value" that indicates where the object is stored.
Therefore, when passing an object as an argument, a copy of its reference value is passed.
As a result, it is easy to misunderstand as if "the object passed as an argument is rewritten by passing by reference".

Realize pass by reference by passing a pointer as an argument.
Golang structs / Arrays (unlike Java objects) are value types. That is, an image that secures a place to store all the fields / elements and stores it in a variable representing a structure.
Therefore, if you pass by value a structure, all of its fields will be copied. Even if this is rewritten, the original structure is not rewritten.
On the other hand, map / slice is a reference type (similar to Java objects). That is, what is contained in the variable is a container that contains the pointer of the element, and the image that follows the pointer to access each element (Reference 09/26/19 0000)).
Therefore, even if these are passed by value, the original map / slice will be rewritten. So it usually doesn't make sense to pointer pass these, and usually doesn't (reference).

I wrote it as if it was passed by reference ≒ passed by pointer, but the details there are detailed in here.
The explanation of value type / reference type may not be accurate, so please take it as an image.