जावा 8 लैम्बडा एक्सप्रेशंस - नेस्टेड क्लास में कई तरीकों के बारे में

84

मैं नई विशेषताओं के बारे में यहां पढ़ रहा हूं: http://www.javaworld.com/article/2078836/java-se/love-and-hate-for-java-8.html

मैंने नीचे उदाहरण देखा:

अनाम वर्ग का उपयोग करना:

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

लम्बडा के साथ:

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

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

... और इसी तरह?

java  lambda  java-8  anonymous-class 
— इष्टतम प्रधानमंत्री
स्रोत
21
फिर आपको केवल अनाम कक्षाओं का उपयोग करना होगा। लंबोदर का परिचय उन्हें पदावनत नहीं करता। लैम्ब्डा का उपयोग केवल कार्यात्मक इंटरफेस के साथ किया जा सकता है।
— रोहित जैन
1
एक ActionListener विधि के रूप में लैम्ब्डा का उपयोग बहुत अजीब है। आप कैसे जानते हैं, कि आप actionPerformedइंटरफ़ेस की विधि को लागू कर रहे हैं ActionListener! "
— 15
3
@bobbel फंक्शनल इंटरफेस की पूरी अवधारणा है, मैं आपको उन पर टिप्पणी करने से पहले उन पर पढ़ने का सुझाव देता हूं।
— स्किवि
मुझे पता है, यह कैसे काम करेगा! मुद्दा यह है कि यह बहुत पठनीय कोड नहीं है, क्या यह है? सिर्फ उल्लेख करना चाहता था ...
— bobbel
3
@ maythesource.com आप दो अतिरिक्त इंटरफेस बना सकते हैं जैसे MousePressedListenerऔर MouseReleasedListenerऔर दो तरीके addMousePressedListener(Button, MousePressedListener)और addMouseReleasedListener(Button, MouseReleasedListener)। फिर आप इन ईवेंट हैंडलर को लागू करने के लिए लैम्ब्डा का उपयोग कर सकते हैं।
— 16 अगस्त को ZhekaKozlov

जवाबों:

80

आप हेल्पर इंटरफेस का उपयोग करके लैम्बदास के साथ बहु-विधि इंटरफेस का उपयोग कर सकते हैं। यह ऐसे श्रोता इंटरफेस के साथ काम करता है जहां अवांछित तरीकों का कार्यान्वयन तुच्छ है (यानी हम सिर्फ वही कर सकते हैं जो 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 !"));
— होल्गर
स्रोत
7
यह मेरे लिए एक समस्या का समाधान करने के लिए लगता है MouseListeners के लिए समस्या है। मुझे लगता है कि एक अनाम वस्तु [पुराना तरीका] संलग्न करना बेहतर काम करता है। यह मुझे एक कीचड़ लगता है।
— ncmathsadist
2
@ncmathsadist: यदि आप चाहें तो अनाम आंतरिक वर्ग दृष्टिकोण का उपयोग करने के लिए स्वतंत्र महसूस करें। यह केवल एक विकल्प है। आप इस उत्तर पर भी विचार कर सकते हैं । वहाँ भी अन्य गतिशील श्रोता जनरेटर है ...
— Holger
11
मेरा मानना ​​है कि इस "कीचड़" को स्वीकृत उत्तर होना चाहिए। ओपी का प्रश्न स्पष्ट रूप से था " यदि कोई व्यक्ति माउस क्लासिस्टनर के साथ क्या करेगा यदि वे अनाम वर्ग के भीतर कई तरीकों को लागू करना चाहते हैं, जैसे:" (जोर मेरा)। वह पूछ रहा है कि जब आप एक से अधिक विधि के साथ एक इंटरफ़ेस है, तो लामा का उपयोग कैसे करें। @ होलजर ने इसका पूरी तरह से जवाब दिया। ओपी स्पष्ट रूप से पहले से ही जानता है कि गैर-कार्यात्मक तरीकों से एक अनाम वर्ग का उपयोग कैसे करें।
@ होल्गर यहां चार में से किस विधि को लैंबडा का उपयोग करने पर बुलाया जाएगा? जैसा कि इन सभी विधियों में एक ही पैरामीटर है।
— ड्रीमकोडर
1
@dreamcoder इन चार विधियों में से कोई भी लंबोदर द्वारा लागू नहीं किया जाएगा, क्योंकि उनमें से कोई भी सार नहीं है। लैम्ब्डा उस mouseClickedविधि को लागू करेगा जिसे MouseListenerइंटरफ़ेस में एक सार पद्धति के रूप में घोषित किया गया है और इंटरफ़ेस द्वारा ओवरराइड नहीं किया गया ClickedListenerहै (इसलिए नाम)।
— होल्गर
89

से JLS 9.8

एक कार्यात्मक इंटरफ़ेस एक इंटरफ़ेस है जिसमें केवल एक सार विधि है, और इस प्रकार यह एक एकल फ़ंक्शन अनुबंध का प्रतिनिधित्व करता है।

लैम्ब्डा को इन कार्यात्मक इंटरफेस की आवश्यकता होती है ताकि उनकी एकल विधि तक सीमित रहे। बेनामी इंटरफेस को अभी भी बहु-विधि इंटरफेस को लागू करने के लिए उपयोग करने की आवश्यकता है।

addMouseListener(new MouseAdapter() {

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

    @Override
    public void mousePressed(MouseEvent e) {
      ...
    }
});
— Reimeus
स्रोत
13
ओपी का सवाल था कि " कोई माउसलिस्टनर के साथ क्या करेगा यदि वे अनाम वर्ग के भीतर कई तरीकों को लागू करना चाहते हैं, उदाहरण के लिए:" (जोर मेरा)। आपके द्वारा दिया गया उत्तर अच्छा था, लेकिन बस कहता है कि आप लैम्बडा विवरण के लिए एक से अधिक तरीकों वाले इंटरफेस का उपयोग नहीं कर सकते। होल्गर का जवाब इसके लिए वर्कअराउंड बताता है। आप अपने स्वयं के इंटरफ़ेस का विस्तार करते हैं, और उन तरीकों के लिए चूक प्रदान करते हैं जो आप नहीं चाहते हैं। यह आपके मेमने के लिए एक छोड़ देता है। यह पहली गंभीर चीज नहीं होगी जिसे लोग जावा 8 कोड में देखते हैं।
34

लैंबडा ईजी ने इस मुद्दे पर विचार किया। कई पुस्तकालयों कार्यात्मक इंटरफेस का उपयोग करते हैं, भले ही वे कार्यात्मक इंटरफ़ेस बनने से पहले वर्षों से डिज़ाइन किए गए थे। लेकिन कभी-कभी ऐसा होता है कि एक वर्ग में कई सार विधियां होती हैं, और आप केवल उनमें से एक लैंबडा के साथ लक्षित करना चाहते हैं।

कारखाने के तरीकों को परिभाषित करने के लिए आधिकारिक तौर पर अनुशंसित पैटर्न यहां है:

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

ये सीधे खुद API द्वारा किए जा सकते हैं (ये अंदर के स्टैटिक तरीके MouseListenerहो सकते हैं) या किसी अन्य लाइब्रेरी में बाहरी सहायक तरीके हो सकते हैं, जिन्हें अनुरक्षकों को इस सुविधा की पेशकश नहीं करना चाहिए। क्योंकि उन स्थितियों का सेट जहां यह आवश्यक था, छोटा है, और वर्कअराउंड इतना सरल है, यह इस कोने के मामले को बचाने के लिए भाषा को आगे बढ़ाने के लिए मजबूर नहीं लगता था।

एक समान चाल के लिए नियोजित किया गया था ThreadLocal; नई स्थिर फैक्टरी विधि देखें withInitial(Supplier<S>)।

(वैसे, जब यह मुद्दा सामने आता है, तो उदाहरण लगभग हमेशा होता है MouseListener, जो उत्साहजनक है क्योंकि यह उन कक्षाओं के सेट का सुझाव देता है जो लैंबडा फ्रेंडली होना चाहते हैं, लेकिन ऐसा नहीं है, वास्तव में बहुत छोटा है।)

— ब्रायन गोएत्ज़
स्रोत
3
यह प्रश्न भी देखें । कुछ अन्य बहु-विधि इंटरफेस हैं, जैसे कि WindowListener, लेकिन उनमें से कुछ अपेक्षाकृत कम हैं।
— स्टुअर्ट मार्क्स
4

एक जावा ActionListenerको केवल एक ही विधि ( actionPerformed(ActionEvent e)) लागू करनी चाहिए । यह जावा 8 फ़ंक्शन में अच्छी तरह से फिट बैठता है इसलिए जावा 8 एक को लागू करने के लिए एक साधारण लंबो प्रदान करता है ActionListener।

MouseAdapterकम से कम दो तरीकों की आवश्यकता होती है ताकि एक के रूप में फिट न हो function।

— OldCurmudgeon
स्रोत
1

मैंने एडॉप्टर कक्षाएं बनाईं जो मुझे लिखने की अनुमति देती हैं (सिंगल-लाइन) लंबो-फंक्शन श्रोताओं, भले ही मूल श्रोता इंटरफ़ेस में एक से अधिक विधि हो।

InsertOrRemoveUpdate एडेप्टर पर ध्यान दें, जो 2 घटनाओं को एक में समेट देता है।

मेरी मूल कक्षा में WindowFocusListener, TableModelListener, TableColumnModelListener और TreeModelListener के लिए कार्यान्वयन शामिल हैं, लेकिन इसने 30000 वर्णों की SO सीमा से अधिक कोड को धकेल दिया।

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
}
— रेटो होहनेर
स्रोत
-4

डिफ़ॉल्ट विधियों को लंबोदर भावों के भीतर से एक्सेस नहीं किया जा सकता है। निम्नलिखित कोड संकलित नहीं करता है:

interface Formula {
    double calculate(int a);

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

केवल कार्यात्मक इंटरफ़ेस के साथ काम (एकल सार विधि केवल + डिफ़ॉल्ट विधियों की कोई संख्या) इसलिए लैम्बडा एक्सर्साइज़ केवल सार पद्धति के साथ काम करते हैं

— रणजीत सिंह राजपुरोहित
स्रोत
1
क्षमा करें, लेकिन मुझे समझ नहीं आता कि यह कैसे प्रश्न से संबंधित है
— एफपीएस
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.