Java Constructors - Order of execution in an inheritance hierarchy

I think there are two things going on here that are throwing you off. The first is that main is a static method, where as the member variables b, c, and l are non-static instance variables. That means that they belong to the objects of the class, not the class itself. So when the class is initialized to run the main method, the contructors of Bread, Cheese, and Lettuce are not called, since no instances of Sandwich have been created.

Not until main actually run, and calls new Sandwich() are any objects actually constructed. At that point, the order of operations is:

1. initialize member fields of the base class(es)
2. run the base class(es) constructor(s)
3. initialize member fields of this class
4. run the constructor of this class

This is done recursively, so in this case, the order would be

1. init fields of Meal (none)
2. run constructor of Meal (prints "Meal")
3. init fields of Lunch (none)
4. run constructor of Lunch (prints "Lunch")
5. init fields of PortableLunch (none)
6. run constructor of PortableLunch (prints "PortableLunch")
7. init fields of Sandwich (prints "Bread", "Cheese", and "Lettuce")
8. run constructor of Sandwich (prints "Sandwich")

The purpose of this order is to ensure that the base class is fully initialized before any code in the subclass is run. This is needed because the within the constructor of the sub-class, it may call a method on the base class. Bad things would happen if that base class did not initialize its members first.

These are instance fields

private Bread b = new Bread();
private Cheese c = new Cheese();
private Lettuce l = new Lettuce();

They only exist (execute) if an instance is created.

The first thing that runs in your program is

public static void main(String[] args) {
     new Sandwich();
}

Super constructors are called implicitly as the first thing in each constructor, ie. before System.out.println

class Meal {
    Meal() { System.out.println("Meal()"); }
}

class Lunch extends Meal {
    Lunch() { System.out.println("Lunch()"); }
}

class PortableLunch extends Lunch {
    PortableLunch() { System.out.println("PortableLunch()");}
}

After the super() calls, instance fields are instantiated again before the constructor code.

The order, reversed

new Sandwich(); // prints last
// the instance fields
super(); // new PortableLunch() prints third
super(); // new Lunch() prints second
super(); // new Meal(); prints first

even though their constructors where called after.

Not after, here how construstor method looks like to compiler :

public Sandwich(){
    super();// note this calls super constructor, which will call it's super and so on till Object's constructor
    //initiate member variables
    System.out.println("Sandwich()");
}