Java 8 Lambda Expressions - วิธีการหลายอย่างในคลาสที่ซ้อนกัน


86

ฉันกำลังอ่านเกี่ยวกับคุณสมบัติใหม่ที่: http://www.javaworld.com/article/2078836/java-se/love-and-hate-for-java-8.html

ฉันเห็นตัวอย่างด้านล่าง:

การใช้คลาส Anonymous:

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

ด้วย Lambda:

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

บางคนจะทำอย่างไรกับ a MouseListenerถ้าพวกเขาต้องการใช้หลายวิธีในคลาสที่ไม่ระบุตัวตนเช่น

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);
}

... และอื่น ๆ ?


22
จากนั้นคุณต้องใช้คลาสที่ไม่ระบุชื่อเท่านั้น การแนะนำแลมด้าไม่ได้ทำให้พวกเขาเลิกใช้งาน Lambdas สามารถใช้ได้กับอินเตอร์เฟสที่ใช้งานได้เท่านั้น
Rohit Jain

1
การใช้ lambdas เป็นวิธี ActionListener นั้นแปลกมาก คุณรู้ได้อย่างไรว่าคุณกำลังใช้วิธีการactionPerformedอินเทอร์เฟซActionListener!
bobbel

3
@bobbel นั่นคือแนวคิดทั้งหมดของ Functional Interfaces ผมขอแนะนำให้คุณอ่านข้อมูลเหล่านี้ก่อนที่จะแสดงความคิดเห็น
skiwi

ฉันรู้ว่ามันจะเป็นอย่างไร! ประเด็นคือรหัสนี้อ่านไม่ออกใช่ไหม แค่อยากจะพูดถึง ...
bobbel

3
@ maythesource.com คุณสามารถสร้างสองอินเตอร์เฟซเพิ่มเติมเช่นMousePressedListenerและMouseReleasedListenerและสองวิธีการและaddMousePressedListener(Button, MousePressedListener) addMouseReleasedListener(Button, MouseReleasedListener)จากนั้นคุณสามารถใช้ lambdas เพื่อใช้ตัวจัดการเหตุการณ์เหล่านี้
ZhekaKozlov

คำตอบ:


83

คุณสามารถใช้อินเทอร์เฟซแบบหลายวิธีกับ lambdas ได้โดยใช้อินเตอร์เฟสตัวช่วย สิ่งนี้ใช้ได้กับอินเทอร์เฟซสำหรับผู้ฟังดังกล่าวซึ่งการนำวิธีการที่ไม่ต้องการไปใช้นั้นเป็นเรื่องเล็กน้อย (เช่นเราสามารถทำสิ่งที่MouseAdapterเสนอได้เช่นกัน):

// 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) {}
}

คุณต้องกำหนดอินเทอร์เฟซผู้ช่วยดังกล่าวเพียงครั้งเดียว

ตอนนี้คุณสามารถเพิ่มผู้ฟังสำหรับเหตุการณ์คลิกในComponent cลักษณะนี้:

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

8
นี่ดูเหมือนว่าฉันจะเป็นวิธีแก้ปัญหาของ Rococco สำหรับปัญหานี้สำหรับ MouseListeners ฉันคิดว่าการแนบวัตถุที่ไม่ระบุตัวตน [วิธีการเดิม] จะได้ผลดีกว่า ดูเหมือนว่าฉันจะเป็นคนขี้ขลาด
ncmathsadist

2
@ncmathsadist: อย่าลังเลที่จะใช้วิธีการชั้นในที่ไม่ระบุชื่อหากคุณต้องการ นี่เป็นเพียงตัวเลือกเท่านั้น คุณอาจพิจารณาคำตอบนี้ด้วย นอกจากนี้ยังมีตัวสร้างฟังก์ชั่นไดนามิกอื่น ๆ ...
Holger

12
ฉันเชื่อว่า "กากตะกอน" นี้ควรเป็นคำตอบที่ได้รับการยอมรับ คำถามจาก OP นั้นชัดเจนว่า " ใครจะทำอะไรกับ MouseListener ถ้าพวกเขาต้องการใช้หลายวิธีในคลาสที่ไม่ระบุตัวตนเช่น:" (เน้นของฉัน) เขาถามวิธีใช้ lamdas เมื่อคุณมีอินเทอร์เฟซที่มีมากกว่าหนึ่งวิธีในนั้น @ โฮลเจอร์ตอบโจทย์นี้ได้อย่างดีเยี่ยม สหกรณ์อย่างเห็นได้ชัดอยู่แล้วรู้วิธีการใช้ที่ไม่ระบุชื่อชั้นในรูปแบบที่ไม่ทำงาน

1
@ Holger จากสี่วิธีนี้จะถูกเรียกเมื่อเราใช้ lambda? เนื่องจากวิธีการทั้งหมดนี้มีพารามิเตอร์เดียวกัน
dreamcoder

1
@dreamcoder จะไม่มีวิธีใดในสี่วิธีที่แลมด้านำมาใช้เนื่องจากไม่มีวิธีใดที่เป็นนามธรรม แลมบ์ดาจะใช้mouseClickedวิธีการที่ได้รับการประกาศว่าเป็นวิธีนามธรรมในMouseListenerอินเทอร์เฟซและไม่ถูกแทนที่โดยClickedListenerอินเทอร์เฟซ (ดังนั้นชื่อ)
Holger

91

จากJLS 9.8

อินเทอร์เฟซที่ใช้งานได้คืออินเทอร์เฟซที่มีวิธีนามธรรมเพียงวิธีเดียวดังนั้นจึงแสดงถึงสัญญาฟังก์ชันเดียว

Lambdas ต้องการอินเทอร์เฟซที่ใช้งานได้เหล่านี้จึงถูก จำกัด ไว้ที่วิธีการเดียว ยังคงต้องใช้อินเทอร์เฟซแบบไม่ระบุชื่อสำหรับการใช้อินเทอร์เฟซแบบหลายวิธี

addMouseListener(new MouseAdapter() {

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

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

13
คำถามจาก OP คือ " ใครจะทำอะไรกับ MouseListener ถ้าพวกเขาต้องการใช้หลายวิธีในคลาสที่ไม่ระบุตัวตนเช่น:" (เน้นของฉัน) คำตอบที่คุณให้นั้นดี แต่เพียงแค่บอกว่าคุณไม่สามารถใช้อินเทอร์เฟซที่มีมากกว่าหนึ่งวิธีสำหรับคำอธิบายแลมบ์ดาคำตอบของ Holgerอธิบายวิธีแก้ปัญหาสำหรับสิ่งนี้ คุณขยายไปยังอินเทอร์เฟซของคุณเองและระบุค่าเริ่มต้นสำหรับวิธีการที่คุณไม่ต้องการ สิ่งนี้จะเหลือไว้สำหรับแลมด้าของคุณ ไม่ใช่สิ่งแรกที่ผู้คนเห็นในโค้ด Java 8

34

Lambda EG ได้พิจารณาปัญหานี้แล้ว ไลบรารีหลายแห่งใช้อินเทอร์เฟซที่ใช้งานได้แม้ว่าจะได้รับการออกแบบมาหลายปีก่อนที่อินเทอร์เฟซที่ใช้งานได้จะกลายเป็นสิ่งต่างๆ แต่บางครั้งมันก็เกิดขึ้นที่คลาสมีวิธีนามธรรมหลายวิธีและคุณต้องการกำหนดเป้าหมายด้วยแลมด้าเท่านั้น

รูปแบบที่แนะนำอย่างเป็นทางการที่นี่คือการกำหนดวิธีการของโรงงาน:

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

API เหล่านี้สามารถทำได้โดยตรง (ซึ่งอาจเป็นวิธีการแบบคงที่ภายในMouseListener) หรืออาจเป็นวิธีการช่วยเหลือภายนอกในไลบรารีอื่น ๆ หากผู้ดูแลระบบเลือกที่จะไม่ให้ความสะดวกนี้ เนื่องจากสถานการณ์ที่จำเป็นต้องใช้มีขนาดเล็กและวิธีแก้ปัญหานั้นง่ายมากจึงดูเหมือนไม่น่าสนใจที่จะขยายภาษาเพิ่มเติมเพื่อช่วยเหลือกรณีมุมนี้

มีการใช้เคล็ดลับคล้าย ๆ กันสำหรับThreadLocal; withInitial(Supplier<S>)ดูวิธีการโรงงานคงใหม่

(ยังไงก็ตามเมื่อมีประเด็นนี้ขึ้นมาตัวอย่างก็แทบจะตลอดเวลา MouseListenerเป็นที่น่าสนับสนุนเนื่องจากแนะนำชุดของชั้นเรียนที่ต้องการเป็นมิตรกับแลมบ์ดา แต่ไม่ใช่นั้นค่อนข้างเล็กจริงๆ)


3
ดูคำถามนี้ด้วย มีอินเทอร์เฟซแบบหลายวิธีอื่น ๆ อีกจำนวนหนึ่งเช่นWindowListenerแต่มีค่อนข้างน้อย
Stuart Marks

4

Java ActionListenerต้องใช้เพียงหนึ่งวิธีเดียว ( actionPerformed(ActionEvent e)) สิ่งนี้เข้ากันได้ดีกับฟังก์ชัน Java 8 ดังนั้น Java 8 จึงจัดเตรียมแลมบ์ดาอย่างง่ายเพื่อใช้งานActionListenerไฟล์.

ต้องมีอย่างน้อยสองวิธีเพื่อไม่พอดีกับเป็นMouseAdapterfunction


1

ฉันสร้างคลาสอะแด็ปเตอร์ที่อนุญาตให้ฉันเขียน (บรรทัดเดียว) ตัวฟังแลมบ์ดาฟังก์ชันแม้ว่าอินเทอร์เฟซตัวฟังดั้งเดิมจะมีมากกว่าหนึ่งวิธี

สังเกตอะแด็ปเตอร์ InsertOrRemoveUpdate ซึ่งยุบ 2 เหตุการณ์ให้เป็นหนึ่งเดียว

คลาสเดิมของฉันยังมีการใช้งานสำหรับ WindowFocusListener, TableModelListener, TableColumnModelListener และ TreeModelListener แต่มันดันโค้ดเกินขีด จำกัด SO ที่ 30000 อักขระ

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
}

-3

ไม่สามารถเข้าถึงเมธอดเริ่มต้นจากภายในนิพจน์แลมบ์ดา รหัสต่อไปนี้ไม่ได้รวบรวม:

interface Formula {
    double calculate(int a);

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

ใช้งานได้กับอินเทอร์เฟซที่ใช้งานได้เท่านั้น (วิธีนามธรรมเดียวเท่านั้น + วิธีการเริ่มต้นจำนวนเท่าใดก็ได้) ดังนั้นการขยายแลมบ์ดาจึงทำงานด้วยวิธีนามธรรม


1
ขออภัยฉันไม่เข้าใจว่าสิ่งนี้เกี่ยวข้องกับคำถามอย่างไร
fps
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.