Memory Management regarding Calling a Method vs. a Simple Operation

I can't get super technical in my answer because I am not that well-versed in the low level memory management models of the JVM, but I will point out two details that may change your opinion. First of all, the simple statements x += y and x -= y (etc.) are still doing assignments to x so that step is pretty much unavoidable no matter how much we optimize (ultimately we're talking about saving a value to use later so we have to do that somewhere). Secondly, there's another reason not to repeat yourself that doesn't have to do with an immediate impact to performance. By calling load(int num) inside load() with a preset value, we are keeping the logic of the load function in one place and keeping the "default" value of num in one place. This means that as specifications and requirements change, the chances of introducing errors are, in a sense, cut in half because there is only one location requiring modification. So not only is this technique DRY, it is also applying the Single Responsibility Principle.

That being said, you are right that there is a cost to every function call and that there is some threshold where performance takes a hit because of the passing of parameters, but in modern environments code readability and modifiability are generally much more dominant concerns because you are likely to have other people reading your code before you have people complaining about it's performance.