具有非SAM接口的lambda的Java习惯用法

Question

在Java中，可以使用lambda而不是匿名类优雅地实现具有单个抽象方法的接口（即SAM类型或功能接口）：

    // SAM ActionListener with anonymous implementation
    button.addActionListener(
        new ActionListener(){
            public void actionPerformed(Event e){
                System.out.println("button via anon!");
            }
        }
    );

可以替换为：

    // SAM ActionListener with lambda implementation
    button.addActionListener(
        e -> System.out.println("button via lambda!")
    );

但是对于具有多种抽象方法的接口，lambda无法直接应用。例如，java.awt.event.WindowListener有七个方法。但是通常一大段代码只对定义这七个方法之一感兴趣。

要使用匿名类重写来实现该行为，我们可以：

    // non-SAM with adapter implementation with override
    window.addWindowListener(
        new WindowAdapter() {
            @Override
            public void windowOpened(Event e){
                System.out.println("WindowAdapter opened via override!");
            }
        }
    );

但是lambdas是否有更优雅的方式？

@FunctionalInterface
public interface ActionListener {
    void actionPerformed(Event e);
}

public interface WindowListener {
    void windowOpened(Event e);

    void windowClosing(Event e);
}

public class WindowAdapter implements WindowListener {

    public void windowOpened(Event e){
        System.out.println("windowOpened in adapter!");
    }

    public void windowClosing(Event e){
        System.out.println("windowClosing in adapter!");
    }
}

注意 ：@ maythesource.com提出了一个类似但更广泛的问题：“
如果某人想要在匿名类中实现多个方法，该如何处理MouseListener？
”最受支持和接受的答案是使用匿名实现。我的问题是有关非SAM类型的优雅lambda解决方案。

Answer 1

我发现的最优雅的方法是使用匿名桥：

    // SAM bridge with lambda implementation
    window.addWindowListener(
        WindowBridge.windowOpened(
            b -> System.out.println("opening via lambda!")
        )
    );

与SAM类型的情况类似，它比匿名适配器还干净：

    // non-SAM with adapter implementation with override
    window.addWindowListener(
        new WindowAdapter() {
            @Override
            public void windowOpened(Event e){
                System.out.println("WindowAdapter opened via override!");
            }
        }
    );

但是它确实需要带有静态工厂的桥，这有点尴尬：

import java.util.function.Consumer;

public interface WindowBridge {

    // SAM for this method
    public abstract class WindowOpened extends WindowAdapter {
        public abstract void windowOpened(Event e);
    }

    // factory bridge
    public static WindowOpened windowOpened(Consumer<Event> c) {
        return new WindowOpened() {
            public void windowOpened(Event e){
                c.accept(e);
            }
        };
    }

    // SAM for this method
    public abstract class WindowClosing extends WindowAdapter {
        public abstract void windowClosing(Event e);
    }

    // factory bridge
    public static WindowClosing windowClosing(Consumer<Event> c) {
        return new WindowClosing() {
            public void windowClosing(Event e){
                c.accept(e);
            }
        };
    }
}