Given an expression `f1() + f2()*f3()` with 3 method calls, java *evaluates* (operands of) *addition operation first*:

```
int result = f1() + f2()*f3();

f1 working
f2 working
f3 working

```

I (wrongly) expected `f2()` to be called first, then `f3()`, and finally `f1()`. Because multiplication shall be evaluated before addition.

So, I don't understand [JLS](https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.7) here - what am I missing?

> 
> 15.7.3. *Evaluation Respects* Parentheses and *Precedence*
> 
> 
> The Java programming language **respects the order of evaluation**
> **indicated** explicitly by parentheses and **implicitly *by operator
>  precedence*.**
> 
> 
> 

How exactly operator precedence is respected in this example?

JLS mentions some exceptions in [15.7.5. Evaluation Order for Other Expressions](https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.7) (method invocation expressions (§15.12.4),method reference expressions (§15.13.3)), but I cannot apply any of those exceptions to my example.

*I understand that JLS guarantees that operands of a binary operation are evaluated left-to-right.* But **in my example in order to understand method invocation sequence it is necessary to understand which operation (and both its operands respectively!) is considered first.** Am I wrong here - why?

More examples:

```
int result = f1() + f2()*f3() + f4() + f5()*f6() + (f7()+f8());

```

proudly produces:

```
f1 working
f2 working
f3 working
f4 working
f5 working
f6 working
f7 working
f8 working

```

Which is 100% left-to-right, totally regardless of operator precedence.

```
int result = f1() + f2() + f3()*f4();

```

produces:

```
f1 working
f2 working
f3 working
f4 working

```

Here the compiler had two options:

1. `f1()+f2()` - addition first
2. `f3()*f4()` - multiplication first

But the *"evaluate-left-to-right rule"* works here as a charm!

This [link](https://stackoverflow.com/questions/6800590/what-are-the-rules-for-evaluation-order-in-java/6801431#6801431) implies that in such examples method calls are always evaluated left-to-right regardless of any parenthesis and associativity rules.