लंबोदर भावों की व्याख्या

मेरे पास लंबोदर भाव और RxJava के बारे में प्रश्न हैं। ये सवाल ज्यादातर लंबोदर भाव या RxJava की अधूरी समझ की चिंता करते हैं। मैं लैम्ब्डा के भावों को यथासंभव सरल रूप में समझाने की कोशिश करूंगा। RxJava मैं अलग से वर्णन करूंगा।

लैम्ब्डा एक्सप्रेशंस और आरएक्सजाव

लंबोदर भाव क्या हैं? लैम्ब्डा अभिव्यक्ति "बस" एक ही तरीका है जो हम हमेशा कर सकते थे, लेकिन एक क्लीनर और कम क्रियात्मक तरीके से अनाम आंतरिक कक्षाओं का उपयोग करने का नया तरीका है।

जावा में एक अनाम आंतरिक वर्ग एक अनाम वर्ग है, इसका उपयोग तब किया जाना चाहिए जब आपको कक्षा या इंटरफ़ेस विधियों को ओवरराइड करने की आवश्यकता हो। एक अनाम आंतरिक वर्ग एक वर्ग या इंटरफ़ेस से बनाया जा सकता है।

उदाहरण के लिए:

abstract class Animal { abstract void speak(); } Animal a = new Animal() { void speak() { System.out.println("Woff"); } }; 

एंड्रॉइड पर, हम आमतौर पर एक श्रोता के रूप में एक अनाम आंतरिक वर्ग का उपयोग करते हैं, उदाहरण के लिए, इस तरह के बटन के लिए:

 Button btn = findViewById(R.id.button); btn.setOnClickListener( new View.OnClickListener() { @Override public void onClick(final View view) { // Do some fancy stuff with the view parameter. } } ); 

आइए लाम्बा के भावों पर वापस जाएं। यह अगला भाग है, जो पिछले कोड का हिस्सा है, जिसे एक अनाम आंतरिक वर्ग माना जाता है।

 new View.OnClickListener() { @Override public void onClick(final View view) { // Do some fancy stuff with the view parameter. } } 

यदि आपको अधिकांश एक विधि से ओवरराइड करने की आवश्यकता होती है तो लैम्ब्डा अभिव्यक्तियों का उपयोग किया जा सकता है सौभाग्य से हमारे लिए, View.OnClickListener में केवल एक ही शामिल है। नीचे दिए गए कोड पर एक नज़र डालें। आपको क्या लगता है कि हमें क्या निकालना है?

 new View.OnClickListener() { @Override public void onClick(final View view) { // Do some fancy stuff with the view parameter. } } 

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

 (view) -> { // Do some fancy stuff with the view parameter. } 

कुछ मामलों में, आपको पैरामीटर में एक प्रकार जोड़ने की आवश्यकता हो सकती है, यदि कंपाइलर इसका अनुमान नहीं लगा सकता है, तो आप इसे पैरामीटर से पहले जोड़कर ऐसा कर सकते हैं:

 (View view) -> { // Do some fancy stuff with the view parameter. } 

आप मल्टी-लाइन कोड का भी उपयोग कर सकते हैं:

 (view) -> { Intent intent = new Intent(context, AuthActivity.class); intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK); view.getContext().startActivity(intent); } 

यदि आपके पास एक ऐसा तरीका है जिसमें दो पैरामीटर हैं ...

 interface MyInterface { abstract void onMethod(int a, int b); } 

... लंबोदर अभिव्यक्ति इस तरह दिखाई देगी:

 (a, b) -> { // Do some fancy stuff with the a and b parameter. } 

यदि विधि में वापसी प्रकार है ...

 interface MySecondInterface { abstract int onSecondMethod(int a, int b); } 

... लंबोदर अभिव्यक्ति इस तरह दिखाई देगी:

 (a, b) -> { return a + b; } 

लेकिन यह सब नहीं है, कुछ विशेष मामले हैं जो कोड को और भी छोटा बनाते हैं। यदि आपके विधि निकाय में कोड की केवल एक पंक्ति है, तो आप घुंघराले ब्रेस को हटा सकते हैं {} । यदि आप घुंघराले ब्रेसिज़ को हटाते हैं, तो आपको निम्नलिखित को छोड़कर अर्धविराम को भी हटाना होगा:

 (a, b) -> return a + b 

एक और चीज है जो हम कर सकते हैं। यदि हमारे पास कोड की केवल एक पंक्ति है, तो संकलक समझ सकता है कि वापस लौटे भाग की आवश्यकता है या नहीं, इसलिए हम इसे इस तरह छोड़ सकते हैं:

 (a, b) -> a + b 

यदि हमारे पास बहु-पंक्ति कोड होता है, तो यह निम्न पर आ जाएगा:

 (a, b) -> { a+=1; return a + b; } 

तो हमने क्या किया है? हमने इसे लिया:

 new MySecondInterface() { @Override public int onSecondMethod(final int a, final int b) { return a + b; } }; 

और इसे इस में बदल दिया:

 (a, b) -> a + b 

केवल एक चीज बची है, विधि संदर्भ। मान लीजिए कि हमारे पास पहले की तरह एक इंटरफ़ेस है, और एक ऐसा तरीका जो इस इंटरफ़ेस को एक पैरामीटर के रूप में स्वीकार करता है:

 public interface Callback { public void onEvent(int event); } public void myMethod(Callback callback){ } 

एक लंबोदर अभिव्यक्ति के बिना, यह इस तरह दिखेगा:

 myMethod(new Callback() { @Override public void onEvent(final int state) { System.out.println(state); } }); 

एक लंबोदर अभिव्यक्ति जोड़ना, जैसा कि हमने पहले किया था, हमें निम्नलिखित मिलते हैं:

 myMethod(state -> System.out.println(state)); 

लेकिन यह सब नहीं है। यदि उपयोग किया गया कोड एकल-पंक्ति है और कहा जाता है कि फ़ंक्शन एक पैरामीटर लेता है, तो हम इस रूप में विधि संदर्भ पास कर सकते हैं:

 myMethod(System.out::println); 

एक और कोड की आवश्यकता के बिना, पैरामीटर स्वचालित रूप से पारित हो जाएगा! कमाल है ना? मुझे आशा है कि आपने कुछ नया सीखा है!