Here is the code:

以下是代码：

public static void main(String[] args) {
        int x = 5;
        int y = 7;
        System.out.print(m(x, y) + " " + x + " " + m(y, x));
    }

    public static int m(int x, int y) {
        x += 2;
        System.out.print(x + " ");
        y -= 2;
        return (x * y);
    }

I tried writing this down on paper and going through the steps. In the first method call, x has 2 added to it and becomes 7, then is printed. Y is subtracted by 2, becoming 5. Then x*y gets returned, which is 7*5 = 35. So I expect 7 35 for now. Then x is printed, so print a 5. Then in the second method call, 2 is added to x again making it 9. 2 is subtracted from y, making 3. Then x*y is returned, outputting 27.

我试着把它写在纸上，一步一步地走。在第一个方法调用中，x加上2，变成7，然后打印出来。Y减去2，等于5。然后返回x*y，即7*5=35。所以我现在预计是7点35分。然后打印x，所以打印一个5。然后在第二个方法调用中，再次将2加到x，使其为9。从y中减去2，得到3。然后返回x*y，输出27。

So in the end, I expect 7 35 5 9 27.

所以最后，我预计是7 35 5 9 27.

So I expect 7 35 for now

That doesn't make sense. Unless you think that java will print each element in m(x, y) + " " + x + " " + m(y, x) 'on the fly'.

那也太没道理了。除非您认为Java会动态打印m(x，y)+“”+x+“”+m(y，x)‘中的每个元素。

That isn't how it works.

事情不是这样运作的。

The compiler first treats this statement as:

编译器首先将此语句视为：

• Invoke m, passing 'x' and 'y'. This prints 7 , and resolves to 35.


• resolve the binary operator of _string concat (A,B) where A is the result of the previous bullet (35) and B is " ". It doesn't get printed. Why would it be? We're just working on figuring out what m(x, y) + " " is, we haven't at all gotten to the idea that this is passed to System.out.print yet.


• This resolves to 35 .


• Next we resolve CONCAT(A, B) where A is that (35 ) and B is x, which resolves to 5. local variables and parameters are unique to each method, the fact that m changes x is just changing its own copy of x, not main's copy of it, so x is still 5. The string we are building up is now 35 5. This still isn't printed for the same reason.


• Next we resolve CONCAT(A, B) where A is that (35 5) and B is , giving us 35 5 .


• Next we resolve CONCAT(A, B) where A is that (35 5 ) and B is m(y, x). To do that we have to invoke m first to know what that really is, so we do that.


• In passing this prints 9 (remember how every method gets its own unique copy? you called m with (y, x), but the first argument is known as x in m, so, it's 7 when called, gets incremented to 9, is printed, and is then multiplied by 3 and returned: 27. So far we've printed 7 9 as part of m calls.


• Finally we can resolve CONCAT(35 5 , 27) which gets us 35 5 27. Which is passed to System.out.print. Which prints it.

Thus: 7 9 35 5 27.

因此：7 9 35 5 27。