Anonymous inner class - How javac work with lambda expression?

Question

In the below working code,

package com.ca.naive;

import java.awt.BorderLayout;
import java.awt.Button;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.GridLayout;
import java.awt.List;
import java.awt.Panel;
import java.awt.TextField;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

public class TodoGUI {
    public static void main(String[] args) {
        List list = new List();
        TextField itemField = new TextField();

        Button addButton = new Button("Add");
        Button removeButton = new Button("Remove");

        addButton.addActionListener(e -> list.add(itemField.getText()));
        removeButton.addActionListener( e -> list.remove(list.getSelectedIndex()));

        Panel buttons = new Panel(new GridLayout(1,0,3,3));
        buttons.add(addButton);
        buttons.add(removeButton);

        Panel bottomPanel = new Panel(new FlowLayout(FlowLayout.RIGHT));
        bottomPanel.add(buttons);

        Panel centerPanel = new Panel(new BorderLayout());
        centerPanel.add(BorderLayout.NORTH, itemField);
        centerPanel.add(BorderLayout.SOUTH, buttons);

        Frame frame = new Frame();
        frame.setLayout( new BorderLayout() );
        frame.add(BorderLayout.WEST, list);
        frame.add(BorderLayout.CENTER, centerPanel);
        frame.pack();
        frame.addWindowListener( new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });

        frame.setVisible(true);
    }
}

---

Does javac replace addButton.addActionListener(e -> list.add(itemField.getText())); syntax with

addButton.addActionListener(new java.awt.Event.ActionListener() {
    public void actionPerformed(java.awt.Event.ActionEvent e) {
        list.add(itemField.getText());
    }
});

?

Answer 1

Does javac replace addButton.addActionListener(e -> list.add(itemField.getText())); syntax with

addButton.addActionListener(new java.awt.Event.ActionListener() {
    public void actionPerformed(java.awt.Event.ActionEvent e) {
        list.add(itemField.getText());
    }
  });

?

No, this is not what the compiler does. In your example, an ActionListener implementation will be generated and instantiated, but that does not happen at compile time; it happens at runtime. The compiler does two things. First, it moves the body of your lambda into a hidden method that looks something like this:

void lambda$1(java.util.List list, java.awt.TextField itemField) {
    list.add(itemField.getText());
}

Second, at the point where your lambda is declared, it emits a call to a bootstrap method. The bootstrap method is a special factory method that knows how to generate an implementation of a functional interface. It needs to be given some basic information, most notably: the type of the functional interface (already known to be ActionListener); the types of any captured variables (in your case, list and itemField); and which method contains the logic for the implementation (the generated lambda$1 method).

When the bootstrap call gets hit at runtime, it will generate an ActionListener implementation. The next time you end up on this code path, you won't have to call the bootsrap method. Instead, the bootstrap call is replaced such that you end up with something equivalent to:

addButton.addActionListener(TodoGUI$Lambda$1.getInstance(list, itemField));

Where TodoGUI$Lambda$1 is a class that looks something like this:

static class TodoGUI$Lambda$1 implements java.awt.Event.ActionListener {
    private final java.util.List list;
    private final java.awt.TextField itemField;

    TodoGUI$Lambda$1(java.util.List list, java.awt.TextField itemField) {
        this.list = list;
        this.itemField = itemField;
    }

    @Override
    public void actionPerformed(java.awt.Event.ActionEvent e) {
        TodoGUI.lambda$1(list, itemField);
    }

    static java.awt.Event.ActionListener getInstance(
        java.util.List list,
        java.awt.TextField itemField) {

        return new TodoGUI$Lambda$1(list, itemField);
    }
}

Now, with all that in mind, the compiler does not need you to import the ActionListener type. That type does not need to be in the lexical scope at all. The compiler will look and see that you are calling a method called addActionListener on an java.awt.Button instance. It will see that you are passing a single argument, which is a lambda expression. In this case, there are no overloads, so it knows that addActionListener expects you to pass an ActionListener. It sees that ActionListener is a single-method interface, meaning it can be bound to a lambda. It attempts to infer your argument types and return type such that they are compatible with what is expected for an ActionListener: a single ActionEvent argument, and a void return type. Your lambda is compatible, so the call is bound, and the steps above are performed.

Answer 2

Another "non-lambda" example of the effect you described is a call like

System.out.println("hello");

You don't need to import java.io.PrintStream in order to use the println method that comes with out being an instance of this class.

BTW: You can program a class without the use of any import statements. In that case you always have to use the full classname including all packages if you want to use it:

java.io.PrintStream outStream = System.out;
outStream.println("Hello");

An import just saves you the repeated specification of the package each time you use a class.