Java中是否有使用方法引用JAVA重写方法的简短形式？

Question

I keep having situations where this would be really handy

component.addWindowListener() { new WindowListener() {
        // quick overriding to make syntax less verbose
        windowClosing(e) -> Foo::doFoo;

        windowActivated(e) -> Foo::doFoo;
    }
}

currently this would mostly look like this:

component.addWindowListener() new WindowListener() {
    @Override
    public void windowClosing(WindowEvent e) {
        Foo.doFoo(e);
    }

    @Override
    public void windowActivated(WindowEvent e) {
        Foo.doFoo(e);
    }
}

Where the method reference points to some function:

public static void doFoo(WindowEvent e) {
    // does code
}

Is anything like this possible? because the whole overriding of non-functional interfaces is quite quite frustrating.

Answer 1

There is no such language feature, but if you have to implement an interface so often that this verbosity becomes relevant, you can write your own adapter.

Eg, with the adapter below, you could write

f.addWindowListener(WindowAdapter.window()
    .onClosing(ev -> ev.getWindow().dispose())
    .onClosed(ev -> System.out.println("closed"))
);

or utilizing the power of import static :

f.addWindowListener(window().onClosing(ev -> System.out.println("closing")));

so, to stay with your example

f.addWindowListener(window().onClosing(Foo::doFoo).onActivated(Foo::doFoo));

Adapter:

public class WindowAdapter implements WindowListener {
    static Consumer<WindowEvent> NO_OP = ev -> {};
    public static WindowAdapter window() {
        return new WindowAdapter(NO_OP, NO_OP, NO_OP, NO_OP, NO_OP, NO_OP, NO_OP);
    }
    final Consumer<WindowEvent> opened, closing, closed,
        iconified, deiconified, activated, deactivated;

    public WindowAdapter(Consumer<WindowEvent> opened, Consumer<WindowEvent> closing,
        Consumer<WindowEvent> closed, Consumer<WindowEvent> iconified,
        Consumer<WindowEvent> deiconified, Consumer<WindowEvent> activated,
        Consumer<WindowEvent> deactivated) {
        this.opened = opened;
        this.closing = closing;
        this.closed = closed;
        this.iconified = iconified;
        this.deiconified = deiconified;
        this.activated = activated;
        this.deactivated = deactivated;
    }
    public WindowAdapter onOpened(Consumer<WindowEvent> c) {
        Objects.requireNonNull(c);
        return new WindowAdapter(opened==NO_OP? c: opened.andThen(c),
            closing, closed, iconified, deiconified, activated, deactivated);
    }
    public WindowAdapter onClosing(Consumer<WindowEvent> c) {
        Objects.requireNonNull(c);
        return new WindowAdapter(opened, closing==NO_OP? c: closing.andThen(c),
            closed, iconified, deiconified, activated, deactivated);
    }
    public WindowAdapter onClosed(Consumer<WindowEvent> c) {
        Objects.requireNonNull(c);
        return new WindowAdapter(opened, closing, closed==NO_OP? c: closed.andThen(c),
            iconified, deiconified, activated, deactivated);
    }
    public WindowAdapter onIconified(Consumer<WindowEvent> c) {
        Objects.requireNonNull(c);
        return new WindowAdapter(opened, closing, closed,
          iconified==NO_OP? c: iconified.andThen(c), deiconified, activated, deactivated);
    }
    public WindowAdapter onDeiconified(Consumer<WindowEvent> c) {
        Objects.requireNonNull(c);
        return new WindowAdapter(opened, closing, closed, iconified,
            deiconified==NO_OP? c: deiconified.andThen(c), activated, deactivated);
    }
    public WindowAdapter onActivated(Consumer<WindowEvent> c) {
        Objects.requireNonNull(c);
        return new WindowAdapter(opened, closing, closed, iconified,
            deiconified, activated==NO_OP? c: activated.andThen(c), deactivated);
    }
    public WindowAdapter onDeactivated(Consumer<WindowEvent> c) {
        Objects.requireNonNull(c);
        return new WindowAdapter(opened, closing, closed, iconified,
            deiconified, activated, deactivated==NO_OP? c: deactivated.andThen(c));
    }
    @Override public void windowOpened(WindowEvent e) { opened.accept(e); }
    @Override public void windowClosing(WindowEvent e) { closing.accept(e); }
    @Override public void windowClosed(WindowEvent e) { closed.accept(e); }
    @Override public void windowIconified(WindowEvent e) { iconified.accept(e); }
    @Override public void windowDeiconified(WindowEvent e) { deiconified.accept(e); }
    @Override public void windowActivated(WindowEvent e) { activated.accept(e); }
    @Override public void windowDeactivated(WindowEvent e) { deactivated.accept(e); }
}

Answer 2

Building on top of Holger's idea , here is an implementation that is a bit simpler. The API is a bit different but you could easily add all the on*() methods if you like:

public class WindowListenerAdapter implements WindowListener {
    private Map<Integer, Consumer<WindowEvent>> listeners = new HashMap<>();

    public static WindowListenerAdapter adapter() {
        return new WindowListenerAdapter();
    }

    public WindowListenerAdapter register(int eventId, Consumer<WindowEvent> listener) {
        if (eventId < WindowEvent.WINDOW_FIRST || eventId > WindowEvent.WINDOW_LAST) {
            throw new IllegalArgumentException("Invalid event id: " + eventId);
        }
        listeners.merge(eventId, listener, Consumer::andThen);
        return this;
    }

    private void processEvent(WindowEvent e) {
        listeners.getOrDefault(e.getID(), i -> {}).accept(e);
    }

    @Override
    public void windowOpened(final WindowEvent e) {
        processEvent(e);
    }

    @Override
    public void windowClosing(final WindowEvent e) {
        processEvent(e);
    }

    @Override
    public void windowClosed(final WindowEvent e) {
        processEvent(e);
    }

    @Override
    public void windowIconified(final WindowEvent e) {
        processEvent(e);
    }

    @Override
    public void windowDeiconified(final WindowEvent e) {
        processEvent(e);
    }

    @Override
    public void windowActivated(final WindowEvent e) {
        processEvent(e);
    }

    @Override
    public void windowDeactivated(final WindowEvent e) {
        processEvent(e);
    }
}

and use it as:

f.addWindowListener(adapter().register(WINDOW_CLOSING, Foo::doFoo)
        .register(WINDOW_ACTIVATED, Foo::doFoo));

You could maybe even add a

public static WindowListenerAdapter forWindow(Window f) {
    final WindowListenerAdapter adapter = adapter();
    f.addWindowListener(adapter);
    return adapter;
}

and use it as:

forWindow(f).register(WINDOW_CLOSING, Foo::doFoo)
        .register(WINDOW_ACTIVATED, Foo::doFoo);

or similarly with

public WindowListenerAdapter on(Window w) {
    w.addWindowListener(this);
    return this;
}

write:

adapter().register(WINDOW_CLOSING, Foo::doFoo)
        .register(WINDOW_ACTIVATED, Foo::doFoo)
        .on(f);

Answer 3

You could write your own class to hold these lambdas and call them as needed. If you do this a lot it might save some code, but in your example you could end up with more lines of code in total.

Answer 4

Is there any short-form for overriding methods in Java with method references ?

Looking at JEP draft: Concise Method Bodies maybe there will be something like that:

    component.addWindowListener(new WindowListener() {
        public void windowClosing(e) -> Foo.doFoo(e);
        public void windowActivated(e) -> Foo.doFoo(e);
    });

and

    component.addWindowListener(new WindowListener() {
        public void windowClosing(e) = Foo::doFoo;
        public void windowActivated(e) = Foo::doFoo;
    });

The uses the syntax to show how

Concise method bodies avoid the line noise, and let you treat the anonymous class almost like a family of lambdas:

The first code uses labda expressions . The second code uses the requested method references .

While this is not a solution yet it may become one. Let's stay tuned.