Order of execution of methods describing an instance and an argument in Java?

Question

In the statement:

fooFunc().barFunc(bazFunc());

barFunc() can obviously not execute until both bazFunc() and fooFunc() have completed.

But is the order of execution of fooFunc() and bazFunc() guaranteed?

Related (but different!) question: Order of execution of parameters guarantees in Java?

Answer 1

The documentation for this is 15.12.4. Run-time Evaluation of Method Invocation

It says "At run-time, method invocation requires five steps. First, a target reference may be computed. Second, the argument expressions are evaluated. Third, the accessibility of the method to be invoked is checked. Fourth, the actual code for the method to be executed is located. Fifth, a new activation frame is created, synchronization is performed if necessary, and control is transferred to the method code."

In the example, fooFunc() is called as part of computing the target reference, and bazFunc() is one of the argument expressions, so fooFunc() must be called first.

Answer 2

The JLS, Java SE 7 Edition has the following example, which says it's fooFunc() before bazFunc(), however I can only find the example - I haven't yet found the associated statement that specifies it:

Example 15.12.4.1-2. Evaluation Order During Method Invocation

As part of an instance method invocation (§15.12), there is an expression that denotes the object to be invoked. This expression appears to be fully evaluated before any part of any argument expression to the method invocation is evaluated. So, for example, in:

class Test2 { 

    public static void main(String[] args) { 
        String s = "one"; 
        if (s.startsWith(s = "two")) 
            System.out.println("oops"); 
    } 
}

the occurrence of s before ".startsWith" is evaluated first, before the argument expression s = "two". Therefore, a reference to the string "one" is remembered as the target reference before the local variable s is changed to refer to the string "two". As a result, the startsWith method is invoked for target object "one" with argument "two", so the result of the invocation is false, as the string "one" does not start with "two". It follows that the test program does not print "oops".

Answer 3

First fooFunc, then bazFunc, and last barFunc

Here's some code that demonstrates it:

public class OrderJava {
  public static void main(String[] args) {
    fooFunc().barFunc(bazFunc());
  }

  public static Bar fooFunc() {
    System.out.println("I am fooFunc!");
    return new Bar();
  }

  public static class Bar {
    public void barFunc(Object o) {
      System.out.println("I am barFunc!");
    }
  }

  public static Object bazFunc() {
    System.out.println("I am bazFunc!");

    return null;
  }
}

The output of this code is:

I am fooFunc!
I am bazFunc!
I am barFunc!

Answer 4

fooFunc() will execute first, followed by bazFunc() and finally barFunc()

We can all agree that fooFunc() must execute before barFunc() has anything to operate on.

Given that bazFunc() will only be called when barFunc() needs it's parameters, it stands to reason that this would happen after fooFunc().