Question: In Java, all variables containing proper objects are actually references (i.e. pointers). Therefore, method calls with these objects as arguments are always "by reference". Calling a method which modifies the state of the object also affects the original object (on the caller side).

C++ is different: Here arguments can be passed by value or passed by reference. Calling a mutator method on an object which was passed by value leaves the original object unaffected. (I suppose call by value creates a local copy of the object).

So my first response to this - coming from Java to C++ - is: ALWAYS use pointers when using objects as arguments. This gives me the behavior I have come to expect from Java.

However, one could also use "call by value" in case one does not need to modify the object in the method body. Are there reasons why one would want to do this?

Answer: 
You normally pass by value because something *is* a value and should act like a value. In many cases passing by const reference is close enough to the same to be worth considering. In other cases, it's not.

Passing by value can also be an [optimization](http://cpp-next.com/archive/2009/08/want-speed-pass-by-value/). At least IMO, this more or less secondary, but it can be important anyway (especially in choosing between passing by const reference and passing a real value.

IMO, the real question should be in the opposite direction: why should the compiler pass a reference when you've clearly told it to pass a value? The answer is "premature optimization". The designers of Java (to mention your example, though it's hardly unique in this) decided that they knew better than to let the compiler do what it was told. Since passing a large object by value *can* be slow and *might* be a mistake, they decided to not let it happen at all, even though it can be fast and may well be exactly what was intended.
I think you should consider the variable types in your function signature as the contract to the caller. So if you declare you function as:

```
void foo( int a );

```

then you are saying i will copy your passed in value do whatever I like and it won't be modified.

If you declare like:

```
void foo (int* a);

```

then I may modify what `a` points to or indeed modify the pointer

so the semantic difference is that you are declaring what the contract of your function may do, with pointers and references (without const declared on the reference or the object that the pointer is pointing to) you may modify the variable. 

References are preferred in C++ as it is clearer what you are intending and you avoid the c style pointer to pointer function signatures that are necessary when passing pointers to functions where you want to modify what the pointer is pointing to, which leads to errors and head scratching before you realise what went wrong.

Pointers though still are very useful as paremeters, especially if you need to test if the pointer to the object is null or not, something that is not possible to do using references.