Expresiones Lambda de Java 8: ¿que pasa con los métodos múltiples en la clase anidada?

Estoy leyendo sobre las nuevas funciones en: http://www.javaworld.com/article/2078836/java-se/love-and-hate-for-java-8.html

Vi el ejemplo a continuación:

Usando la clase anónima:

button.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent ae) {
        System.out.println("Action Detected");
    }
});

Con Lambda:

button.addActionListener(e -> {
    System.out.println("Action Detected");
});

¿Qué haría alguien con a MouseListenersi quisiera implementar varios métodos dentro de la clase anónima, por ejemplo:

public void mousePressed(MouseEvent e) {
    saySomething("Mouse pressed; # of clicks: "
               + e.getClickCount(), e);
}

public void mouseReleased(MouseEvent e) {
    saySomething("Mouse released; # of clicks: "
               + e.getClickCount(), e);
}

... ¿y así?

Puede utilizar interfaces de varios métodos con lambdas utilizando interfaces de ayuda. Esto funciona con interfaces de escucha en las que las implementaciones de métodos no deseados son triviales (es decir, también podemos hacer lo que MouseAdapterofrece):

// note the absence of mouseClicked…
interface ClickedListener extends MouseListener
{
    @Override
    public default void mouseEntered(MouseEvent e) {}

    @Override
    public default void mouseExited(MouseEvent e) {}

    @Override
    public default void mousePressed(MouseEvent e) {}

    @Override
    public default void mouseReleased(MouseEvent e) {}
}

Debe definir dicha interfaz auxiliar solo una vez.

Ahora puede agregar un oyente para eventos de clic en un Component caspecto como este:

c.addMouseListener((ClickedListener)(e)->System.out.println("Clicked !"));

Desde JLS 9.8

Una interfaz funcional es una interfaz que tiene un solo método abstracto y, por lo tanto, representa un contrato de función única.

Las lambdas requieren estas interfaces funcionales, por lo que están restringidas a su método único. Aún es necesario utilizar interfaces anónimas para implementar interfaces de múltiples métodos.

addMouseListener(new MouseAdapter() {

    @Override
    public void mouseReleased(MouseEvent e) {
       ...
    }

    @Override
    public void mousePressed(MouseEvent e) {
      ...
    }
});

El Lambda EG consideró este tema. Muchas bibliotecas usan interfaces funcionales, aunque fueron diseñadas años antes de que la interfaz funcional se convirtiera en algo. Pero a veces sucede que una clase tiene varios métodos abstractos y solo desea apuntar a uno de ellos con una lambda.

El patrón oficialmente recomendado aquí es definir métodos de fábrica:

static MouseListener clickHandler(Consumer<MouseEvent> c) { return ... }

Estos pueden ser realizados directamente por las propias API (estos podrían ser métodos estáticos dentro de MouseListener) o podrían ser métodos auxiliares externos en alguna otra biblioteca en caso de que los mantenedores elijan no ofrecer esta conveniencia. Debido a que el conjunto de situaciones en las que se necesitaba esto es pequeño y la solución alternativa es tan simple, no parecía convincente extender el lenguaje más para rescatar este caso de esquina.

Se empleó un truco similar para ThreadLocal ; consulte el nuevo método de fábrica estática withInitial(Supplier<S>).

(Por cierto, cuando surge este problema, el ejemplo es casi siempre MouseListener, lo cual es alentador ya que sugiere que el conjunto de clases que quisieran ser compatibles con lambda, pero no lo son, es en realidad bastante pequeño).

Un Java ActionListenerdebe implementar un solo método ( actionPerformed(ActionEvent e)). Esto encaja muy bien en la función de Java 8 , por lo que Java 8 proporciona una lambda simple para implementar un ActionListener.

El MouseAdapterrequiere al menos dos métodos de modo que no encaja como un function.

Creé clases de adaptador que me permiten escribir oyentes de función lambda (de una sola línea), incluso si la interfaz del oyente original contiene más de un método.

Tenga en cuenta el adaptador InsertOrRemoveUpdate, que contrae 2 eventos en uno.

Mi clase original también contenía implementaciones para WindowFocusListener, TableModelListener, TableColumnModelListener y TreeModelListener, pero eso empujó el código por encima del límite de SO de 30000 caracteres.

import java.awt.event.*;
import java.beans.*;
import javax.swing.*;
import javax.swing.event.*;
import org.slf4j.*;

public class Adapters {
  private static final Logger LOGGER = LoggerFactory.getLogger(Adapters.class);

  @FunctionalInterface
  public static interface AdapterEventHandler<EVENT> {
    void handle(EVENT e) throws Exception;

    default void handleWithRuntimeException(EVENT e) {
      try {
        handle(e);
      }
      catch(Exception exception) {
        throw exception instanceof RuntimeException ? (RuntimeException) exception : new RuntimeException(exception);
      }
    }
  }

  public static void main(String[] args) throws Exception {
    // -------------------------------------------------------------------------------------------------------------------------------------
    // demo usage
    // -------------------------------------------------------------------------------------------------------------------------------------
    JToggleButton toggleButton = new JToggleButton();
    JFrame frame = new JFrame();
    JTextField textField = new JTextField();
    JScrollBar scrollBar = new JScrollBar();
    ListSelectionModel listSelectionModel = new DefaultListSelectionModel();

    // ActionListener
    toggleButton.addActionListener(ActionPerformed.handle(e -> LOGGER.info(e.toString())));

    // ItemListener
    toggleButton.addItemListener(ItemStateChanged.handle(e -> LOGGER.info(e.toString())));

    // ChangeListener
    toggleButton.addChangeListener(StateChanged.handle(e -> LOGGER.info(e.toString())));

    // MouseListener
    frame.addMouseListener(MouseClicked.handle(e -> LOGGER.info(e.toString())));
    frame.addMouseListener(MousePressed.handle(e -> LOGGER.info(e.toString())));
    frame.addMouseListener(MouseReleased.handle(e -> LOGGER.info(e.toString())));
    frame.addMouseListener(MouseEntered.handle(e -> LOGGER.info(e.toString())));
    frame.addMouseListener(MouseExited.handle(e -> LOGGER.info(e.toString())));

    // MouseMotionListener
    frame.addMouseMotionListener(MouseDragged.handle(e -> LOGGER.info(e.toString())));
    frame.addMouseMotionListener(MouseMoved.handle(e -> LOGGER.info(e.toString())));

    // MouseWheelListenere
    frame.addMouseWheelListener(MouseWheelMoved.handle(e -> LOGGER.info(e.toString())));

    // KeyListener
    frame.addKeyListener(KeyTyped.handle(e -> LOGGER.info(e.toString())));
    frame.addKeyListener(KeyPressed.handle(e -> LOGGER.info(e.toString())));
    frame.addKeyListener(KeyReleased.handle(e -> LOGGER.info(e.toString())));

    // FocusListener
    frame.addFocusListener(FocusGained.handle(e -> LOGGER.info(e.toString())));
    frame.addFocusListener(FocusLost.handle(e -> LOGGER.info(e.toString())));

    // ComponentListener
    frame.addComponentListener(ComponentMoved.handle(e -> LOGGER.info(e.toString())));
    frame.addComponentListener(ComponentResized.handle(e -> LOGGER.info(e.toString())));
    frame.addComponentListener(ComponentShown.handle(e -> LOGGER.info(e.toString())));
    frame.addComponentListener(ComponentHidden.handle(e -> LOGGER.info(e.toString())));

    // ContainerListener
    frame.addContainerListener(ComponentAdded.handle(e -> LOGGER.info(e.toString())));
    frame.addContainerListener(ComponentRemoved.handle(e -> LOGGER.info(e.toString())));

    // HierarchyListener
    frame.addHierarchyListener(HierarchyChanged.handle(e -> LOGGER.info(e.toString())));

    // PropertyChangeListener
    frame.addPropertyChangeListener(PropertyChange.handle(e -> LOGGER.info(e.toString())));
    frame.addPropertyChangeListener("propertyName", PropertyChange.handle(e -> LOGGER.info(e.toString())));

    // WindowListener
    frame.addWindowListener(WindowOpened.handle(e -> LOGGER.info(e.toString())));
    frame.addWindowListener(WindowClosing.handle(e -> LOGGER.info(e.toString())));
    frame.addWindowListener(WindowClosed.handle(e -> LOGGER.info(e.toString())));
    frame.addWindowListener(WindowIconified.handle(e -> LOGGER.info(e.toString())));
    frame.addWindowListener(WindowDeiconified.handle(e -> LOGGER.info(e.toString())));
    frame.addWindowListener(WindowActivated.handle(e -> LOGGER.info(e.toString())));
    frame.addWindowListener(WindowDeactivated.handle(e -> LOGGER.info(e.toString())));

    // WindowStateListener
    frame.addWindowStateListener(WindowStateChanged.handle(e -> LOGGER.info(e.toString())));

    // DocumentListener
    textField.getDocument().addDocumentListener(InsertUpdate.handle(e -> LOGGER.info(e.toString())));
    textField.getDocument().addDocumentListener(RemoveUpdate.handle(e -> LOGGER.info(e.toString())));
    textField.getDocument().addDocumentListener(InsertOrRemoveUpdate.handle(e -> LOGGER.info(e.toString())));
    textField.getDocument().addDocumentListener(ChangedUpdate.handle(e -> LOGGER.info(e.toString())));

    // AdjustmentListener
    scrollBar.addAdjustmentListener(AdjustmentValueChanged.handle(e -> LOGGER.info(e.toString())));

    // ListSelectionListener
    listSelectionModel.addListSelectionListener(ValueChanged.handle(e -> LOGGER.info(e.toString())));

    // ...
    // enhance as needed
  }

  // @formatter:off
  // ---------------------------------------------------------------------------------------------------------------------------------------
  // ActionListener
  // ---------------------------------------------------------------------------------------------------------------------------------------
  public static class ActionPerformed implements ActionListener {
    private AdapterEventHandler<ActionEvent> m_handler = null;
    public static ActionPerformed handle(AdapterEventHandler<ActionEvent> handler) { ActionPerformed adapter = new ActionPerformed(); adapter.m_handler = handler; return adapter; }
    @Override public void actionPerformed(ActionEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  // ---------------------------------------------------------------------------------------------------------------------------------------
  // ItemListener
  // ---------------------------------------------------------------------------------------------------------------------------------------
  public static class ItemStateChanged implements ItemListener {
    private AdapterEventHandler<ItemEvent> m_handler = null;
    public static ItemStateChanged handle(AdapterEventHandler<ItemEvent> handler) { ItemStateChanged adapter = new ItemStateChanged(); adapter.m_handler = handler; return adapter; }
    @Override public void itemStateChanged(ItemEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  // ---------------------------------------------------------------------------------------------------------------------------------------
  // ChangeListener
  // ---------------------------------------------------------------------------------------------------------------------------------------
  public static class StateChanged implements ChangeListener {
    private AdapterEventHandler<ChangeEvent> m_handler = null;
    public static StateChanged handle(AdapterEventHandler<ChangeEvent> handler) { StateChanged adapter = new StateChanged(); adapter.m_handler = handler; return adapter; }
    @Override public void stateChanged(ChangeEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  // ---------------------------------------------------------------------------------------------------------------------------------------
  // MouseListener
  // ---------------------------------------------------------------------------------------------------------------------------------------
  public static class MouseClicked extends MouseAdapter {
    private AdapterEventHandler<MouseEvent> m_handler = null;
    public static MouseClicked handle(AdapterEventHandler<MouseEvent> handler) { MouseClicked adapter = new MouseClicked(); adapter.m_handler = handler; return adapter; }
    @Override public void mouseClicked(MouseEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  public static class MousePressed extends MouseAdapter {
    private AdapterEventHandler<MouseEvent> m_handler = null;
    public static MousePressed handle(AdapterEventHandler<MouseEvent> handler) { MousePressed adapter = new MousePressed(); adapter.m_handler = handler; return adapter; }
    @Override public void mousePressed(MouseEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  public static class MouseReleased extends MouseAdapter {
    private AdapterEventHandler<MouseEvent> m_handler = null;
    public static MouseReleased handle(AdapterEventHandler<MouseEvent> handler) { MouseReleased adapter = new MouseReleased(); adapter.m_handler = handler; return adapter; }
    @Override public void mouseReleased(MouseEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  public static class MouseEntered extends MouseAdapter {
    private AdapterEventHandler<MouseEvent> m_handler = null;
    public static MouseEntered handle(AdapterEventHandler<MouseEvent> handler) { MouseEntered adapter = new MouseEntered(); adapter.m_handler = handler; return adapter; }
    @Override public void mouseEntered(MouseEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  public static class MouseExited extends MouseAdapter {
    private AdapterEventHandler<MouseEvent> m_handler = null;
    public static MouseExited handle(AdapterEventHandler<MouseEvent> handler) { MouseExited adapter = new MouseExited(); adapter.m_handler = handler; return adapter; }
    @Override public void mouseExited(MouseEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  // ---------------------------------------------------------------------------------------------------------------------------------------
  // MouseMotionListener
  // ---------------------------------------------------------------------------------------------------------------------------------------
  public static class MouseDragged extends MouseAdapter {
    private AdapterEventHandler<MouseEvent> m_handler = null;
    public static MouseDragged handle(AdapterEventHandler<MouseEvent> handler) { MouseDragged adapter = new MouseDragged(); adapter.m_handler = handler; return adapter; }
    @Override public void mouseDragged(MouseEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  public static class MouseMoved extends MouseAdapter {
    private AdapterEventHandler<MouseEvent> m_handler = null;
    public static MouseMoved handle(AdapterEventHandler<MouseEvent> handler) { MouseMoved adapter = new MouseMoved(); adapter.m_handler = handler; return adapter; }
    @Override public void mouseMoved(MouseEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  // ---------------------------------------------------------------------------------------------------------------------------------------
  // MouseWheelListener
  // ---------------------------------------------------------------------------------------------------------------------------------------
  public static class MouseWheelMoved extends MouseAdapter {
    private AdapterEventHandler<MouseWheelEvent> m_handler = null;
    public static MouseWheelMoved handle(AdapterEventHandler<MouseWheelEvent> handler) { MouseWheelMoved adapter = new MouseWheelMoved(); adapter.m_handler = handler; return adapter; }
    @Override public void mouseWheelMoved(MouseWheelEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  // ---------------------------------------------------------------------------------------------------------------------------------------
  // KeyListener
  // ---------------------------------------------------------------------------------------------------------------------------------------
  public static class KeyTyped extends KeyAdapter {
    private AdapterEventHandler<KeyEvent> m_handler = null;
    public static KeyTyped handle(AdapterEventHandler<KeyEvent> handler) { KeyTyped adapter = new KeyTyped(); adapter.m_handler = handler; return adapter; }
    @Override public void keyTyped(KeyEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  public static class KeyPressed extends KeyAdapter {
    private AdapterEventHandler<KeyEvent> m_handler = null;
    public static KeyPressed handle(AdapterEventHandler<KeyEvent> handler) { KeyPressed adapter = new KeyPressed(); adapter.m_handler = handler; return adapter; }
    @Override public void keyPressed(KeyEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  public static class KeyReleased extends KeyAdapter {
    private AdapterEventHandler<KeyEvent> m_handler = null;
    public static KeyReleased handle(AdapterEventHandler<KeyEvent> handler) { KeyReleased adapter = new KeyReleased(); adapter.m_handler = handler; return adapter; }
    @Override public void keyReleased(KeyEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  // ---------------------------------------------------------------------------------------------------------------------------------------
  // FocusListener
  // ---------------------------------------------------------------------------------------------------------------------------------------
  public static class FocusGained extends FocusAdapter {
    private AdapterEventHandler<FocusEvent> m_handler = null;
    public static FocusGained handle(AdapterEventHandler<FocusEvent> handler) { FocusGained adapter = new FocusGained(); adapter.m_handler = handler; return adapter; }
    @Override public void focusGained(FocusEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  public static class FocusLost extends FocusAdapter {
    private AdapterEventHandler<FocusEvent> m_handler = null;
    public static FocusLost handle(AdapterEventHandler<FocusEvent> handler) { FocusLost adapter = new FocusLost(); adapter.m_handler = handler; return adapter; }
    @Override public void focusLost(FocusEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  // ---------------------------------------------------------------------------------------------------------------------------------------
  // ComponentListener
  // ---------------------------------------------------------------------------------------------------------------------------------------
  public static class ComponentMoved extends ComponentAdapter {
    private AdapterEventHandler<ComponentEvent> m_handler = null;
    public static ComponentMoved handle(AdapterEventHandler<ComponentEvent> handler) { ComponentMoved adapter = new ComponentMoved(); adapter.m_handler = handler; return adapter; }
    @Override public void componentMoved(ComponentEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  public static class ComponentResized extends ComponentAdapter {
    private AdapterEventHandler<ComponentEvent> m_handler = null;
    public static ComponentResized handle(AdapterEventHandler<ComponentEvent> handler) { ComponentResized adapter = new ComponentResized(); adapter.m_handler = handler; return adapter; }
    @Override public void componentResized(ComponentEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  public static class ComponentShown extends ComponentAdapter {
    private AdapterEventHandler<ComponentEvent> m_handler = null;
    public static ComponentShown handle(AdapterEventHandler<ComponentEvent> handler) { ComponentShown adapter = new ComponentShown(); adapter.m_handler = handler; return adapter; }
    @Override public void componentShown(ComponentEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  public static class ComponentHidden extends ComponentAdapter {
    private AdapterEventHandler<ComponentEvent> m_handler = null;
    public static ComponentHidden handle(AdapterEventHandler<ComponentEvent> handler) { ComponentHidden adapter = new ComponentHidden(); adapter.m_handler = handler; return adapter; }
    @Override public void componentHidden(ComponentEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  // ---------------------------------------------------------------------------------------------------------------------------------------
  // ContainerListener
  // ---------------------------------------------------------------------------------------------------------------------------------------
  public static class ComponentAdded extends ContainerAdapter {
    private AdapterEventHandler<ContainerEvent> m_handler = null;
    public static ComponentAdded handle(AdapterEventHandler<ContainerEvent> handler) { ComponentAdded adapter = new ComponentAdded(); adapter.m_handler = handler; return adapter; }
    @Override public void componentAdded(ContainerEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  public static class ComponentRemoved extends ContainerAdapter {
    private AdapterEventHandler<ContainerEvent> m_handler = null;
    public static ComponentRemoved handle(AdapterEventHandler<ContainerEvent> handler) { ComponentRemoved adapter = new ComponentRemoved(); adapter.m_handler = handler; return adapter; }
    @Override public void componentRemoved(ContainerEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  // ---------------------------------------------------------------------------------------------------------------------------------------
  // HierarchyListener
  // ---------------------------------------------------------------------------------------------------------------------------------------
  public static class HierarchyChanged implements HierarchyListener {
    private AdapterEventHandler<HierarchyEvent> m_handler = null;
    public static HierarchyChanged handle(AdapterEventHandler<HierarchyEvent> handler) { HierarchyChanged adapter = new HierarchyChanged(); adapter.m_handler = handler; return adapter; }
    @Override public void hierarchyChanged(HierarchyEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  // ---------------------------------------------------------------------------------------------------------------------------------------
  // PropertyChangeListener
  // ---------------------------------------------------------------------------------------------------------------------------------------
  public static class PropertyChange implements PropertyChangeListener {
    private AdapterEventHandler<PropertyChangeEvent> m_handler = null;
    public static PropertyChange handle(AdapterEventHandler<PropertyChangeEvent> handler) { PropertyChange adapter = new PropertyChange(); adapter.m_handler = handler; return adapter; }
    @Override public void propertyChange(PropertyChangeEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  // ---------------------------------------------------------------------------------------------------------------------------------------
  // WindowListener
  // ---------------------------------------------------------------------------------------------------------------------------------------
  public static class WindowOpened extends WindowAdapter {
    private AdapterEventHandler<WindowEvent> m_handler = null;
    public static WindowOpened handle(AdapterEventHandler<WindowEvent> handler) { WindowOpened adapter = new WindowOpened(); adapter.m_handler = handler; return adapter; }
    @Override public void windowOpened(WindowEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  public static class WindowClosing extends WindowAdapter {
    private AdapterEventHandler<WindowEvent> m_handler = null;
    public static WindowClosing handle(AdapterEventHandler<WindowEvent> handler) { WindowClosing adapter = new WindowClosing(); adapter.m_handler = handler; return adapter; }
    @Override public void windowClosing(WindowEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  public static class WindowClosed extends WindowAdapter {
    private AdapterEventHandler<WindowEvent> m_handler = null;
    public static WindowClosed handle(AdapterEventHandler<WindowEvent> handler) { WindowClosed adapter = new WindowClosed(); adapter.m_handler = handler; return adapter; }
    @Override public void windowClosed(WindowEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  public static class WindowIconified extends WindowAdapter {
    private AdapterEventHandler<WindowEvent> m_handler = null;
    public static WindowIconified handle(AdapterEventHandler<WindowEvent> handler) { WindowIconified adapter = new WindowIconified(); adapter.m_handler = handler; return adapter; }
    @Override public void windowIconified(WindowEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  public static class WindowDeiconified extends WindowAdapter {
    private AdapterEventHandler<WindowEvent> m_handler = null;
    public static WindowDeiconified handle(AdapterEventHandler<WindowEvent> handler) { WindowDeiconified adapter = new WindowDeiconified(); adapter.m_handler = handler; return adapter; }
    @Override public void windowDeiconified(WindowEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  public static class WindowActivated extends WindowAdapter {
    private AdapterEventHandler<WindowEvent> m_handler = null;
    public static WindowActivated handle(AdapterEventHandler<WindowEvent> handler) { WindowActivated adapter = new WindowActivated(); adapter.m_handler = handler; return adapter; }
    @Override public void windowActivated(WindowEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  public static class WindowDeactivated extends WindowAdapter {
    private AdapterEventHandler<WindowEvent> m_handler = null;
    public static WindowDeactivated handle(AdapterEventHandler<WindowEvent> handler) { WindowDeactivated adapter = new WindowDeactivated(); adapter.m_handler = handler; return adapter; }
    @Override public void windowDeactivated(WindowEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  // ---------------------------------------------------------------------------------------------------------------------------------------
  // WindowStateListener
  // ---------------------------------------------------------------------------------------------------------------------------------------
  public static class WindowStateChanged extends WindowAdapter {
    private AdapterEventHandler<WindowEvent> m_handler = null;
    public static WindowStateChanged handle(AdapterEventHandler<WindowEvent> handler) { WindowStateChanged adapter = new WindowStateChanged(); adapter.m_handler = handler; return adapter; }
    @Override public void windowStateChanged(WindowEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  // ---------------------------------------------------------------------------------------------------------------------------------------
  // DocumentListener
  // ---------------------------------------------------------------------------------------------------------------------------------------
  public static class DocumentAdapter implements DocumentListener {
    @Override public void insertUpdate(DocumentEvent e) { /* nothing */ }
    @Override public void removeUpdate(DocumentEvent e) { /* nothing */ }
    @Override public void changedUpdate(DocumentEvent e) { /* nothing */ }
  }

  public static class InsertUpdate extends DocumentAdapter {
    private AdapterEventHandler<DocumentEvent> m_handler = null;
    public static InsertUpdate handle(AdapterEventHandler<DocumentEvent> handler) { InsertUpdate adapter = new InsertUpdate(); adapter.m_handler = handler; return adapter; }
    @Override public void insertUpdate(DocumentEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  public static class RemoveUpdate extends DocumentAdapter {
    private AdapterEventHandler<DocumentEvent> m_handler = null;
    public static RemoveUpdate handle(AdapterEventHandler<DocumentEvent> handler) { RemoveUpdate adapter = new RemoveUpdate(); adapter.m_handler = handler; return adapter; }
    @Override public void removeUpdate(DocumentEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  public static class InsertOrRemoveUpdate extends DocumentAdapter {
    private AdapterEventHandler<DocumentEvent> m_handler = null;
    public static InsertOrRemoveUpdate handle(AdapterEventHandler<DocumentEvent> handler) { InsertOrRemoveUpdate adapter = new InsertOrRemoveUpdate(); adapter.m_handler = handler; return adapter; }
    @Override public void insertUpdate(DocumentEvent e) { m_handler.handleWithRuntimeException(e); }
    @Override public void removeUpdate(DocumentEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  public static class ChangedUpdate extends DocumentAdapter {
    private AdapterEventHandler<DocumentEvent> m_handler = null;
    public static ChangedUpdate handle(AdapterEventHandler<DocumentEvent> handler) { ChangedUpdate adapter = new ChangedUpdate(); adapter.m_handler = handler; return adapter; }
    @Override public void changedUpdate(DocumentEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  // ---------------------------------------------------------------------------------------------------------------------------------------
  // AdjustmentListener
  // ---------------------------------------------------------------------------------------------------------------------------------------
  public static class AdjustmentValueChanged implements AdjustmentListener {
    private AdapterEventHandler<AdjustmentEvent> m_handler = null;
    public static AdjustmentValueChanged handle(AdapterEventHandler<AdjustmentEvent> handler) { AdjustmentValueChanged adapter = new AdjustmentValueChanged(); adapter.m_handler = handler; return adapter; }
    @Override public void adjustmentValueChanged(AdjustmentEvent e) { m_handler.handleWithRuntimeException(e); }
  }

  // ---------------------------------------------------------------------------------------------------------------------------------------
  // ListSelectionListener
  // ---------------------------------------------------------------------------------------------------------------------------------------
  public static class ValueChanged implements ListSelectionListener {
    private AdapterEventHandler<ListSelectionEvent> m_handler = null;
    public static ValueChanged handle(AdapterEventHandler<ListSelectionEvent> handler) { ValueChanged adapter = new ValueChanged(); adapter.m_handler = handler; return adapter; }
    @Override public void valueChanged(ListSelectionEvent e) { m_handler.handleWithRuntimeException(e); }
  }
  // @formatter:on
}

No se puede acceder a los métodos predeterminados desde dentro de las expresiones lambda. El siguiente código no se compila:

interface Formula {
    double calculate(int a);

    default double sqrt(int a) {
        return Math.sqrt(a);
    }
}
Formula formula = (a) -> sqrt( a * 100);

solo funciona con interfaz funcional (solo método abstracto único + cualquier número de métodos predeterminados) por lo que la expresión lambda funciona solo con método abstracto