किताब “हेड फर्स्ट। कोटलिन »

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

कट के नीचे एक अंश "डेटा क्लासेस" प्रस्तुत किया गया है।

डेटा के साथ काम करें

कोई भी समय बर्बाद नहीं करना चाहता है और पहले से ही जो किया गया है उसे फिर से करना चाहता है। अधिकांश एप्लिकेशन डेटा संग्रहीत करने के लिए कक्षाओं का उपयोग करते हैं। काम को सरल बनाने के लिए, कोटलिन के रचनाकारों ने एक डेटा वर्ग की अवधारणा का प्रस्ताव रखा। इस अध्याय में, आप सीखेंगे कि कैसे डेटा कक्षाएं आपको अधिक सुरुचिपूर्ण और संक्षिप्त कोड लिखने में मदद करती हैं जो आप केवल पहले का सपना देख सकते थे। हम डेटा वर्गों के सहायक कार्यों को देखेंगे और सीखेंगे कि डेटा ऑब्जेक्ट को घटकों में कैसे विघटित किया जाए। उसी समय, हम यह वर्णन करेंगे कि कैसे डिफ़ॉल्ट पैरामीटर मान कोड को अधिक लचीला बनाते हैं, और सभी सुपरक्लासेस के पूर्वज, किसी भी से आपका परिचय कराते हैं।

== ऑपरेटर बराबर नामक एक फ़ंक्शन को कॉल करता है

जैसा कि आप पहले से ही जानते हैं, == ऑपरेटर का उपयोग समानता को सत्यापित करने के लिए किया जा सकता है। जितनी बार == स्टेटमेंट को निष्पादित किया जाता है, एक फ़ंक्शन को समान कहा जाता है। प्रत्येक ऑब्जेक्ट में एक समान फ़ंक्शन होता है, और इस फ़ंक्शन का कार्यान्वयन == ऑपरेटर के व्यवहार को निर्धारित करता है।

डिफ़ॉल्ट रूप से, समानता चेक करने के लिए फ़ंक्शन बराबर होता है कि क्या दो चर एक ही ऑब्जेक्ट के संदर्भ में हैं।

यह समझने के लिए कि यह कैसे काम करता है, w1 और w2 नामक दो वुल्फ चर की कल्पना करें। यदि w1 और w2 में एक वुल्फ ऑब्जेक्ट के संदर्भ होते हैं, तो उनकी तुलना == ऑपरेटर के साथ करने पर, परिणाम सत्य है:


लेकिन अगर w1 और w2 में अलग-अलग वुल्फ ऑब्जेक्ट्स के संदर्भ होते हैं, तो उनकी तुलना == ऑपरेटर के साथ करने पर परिणाम गलत मिलता है, भले ही ऑब्जेक्ट्स में समान गुण मान हों।


जैसा कि पहले उल्लेख किया गया है, समान फ़ंक्शन स्वचालित रूप से आपके द्वारा बनाई गई प्रत्येक ऑब्जेक्ट में शामिल होता है। लेकिन यह फ़ंक्शन कहां से आता है?

सुपरक्लास किसी से विरासत में मिलती है

प्रत्येक ऑब्जेक्ट में एक फ़ंक्शन होता है जिसे समतुल्य कहा जाता है क्योंकि इसका वर्ग किसी भी नाम के वर्ग से एक फ़ंक्शन प्राप्त करता है। कोई भी वर्ग सभी वर्गों का पूर्वज है: परिणामी सुपरक्लास। प्रत्येक वर्ग जिसे आप परिभाषित करते हैं, किसी भी का एक उपवर्ग है, और आपको इसे कार्यक्रम में इंगित करने की आवश्यकता नहीं है। इस प्रकार, यदि आप myClass नामक एक वर्ग कोड लिखते हैं, जो इस तरह दिखता है:

class MyClass { ... } 

कंपाइलर स्वचालित रूप से इसे निम्न रूप में बदल देगा:

प्रत्येक वर्ग किसी भी का एक उपवर्ग है और उसके व्यवहार को विरासत में मिला है। प्रत्येक वर्ग किसी भी का एक उपवर्ग है, और आपको इस कार्यक्रम में रिपोर्ट करने की आवश्यकता नहीं है।

किसी भी विरासत का महत्व

परिणामी सुपरक्लास के रूप में किसी को भी शामिल करने के दो महत्वपूर्ण फायदे हैं:

• यह सुनिश्चित करता है कि प्रत्येक वर्ग को सामान्य व्यवहार विरासत में मिले। कोई भी वर्ग महत्वपूर्ण व्यवहार को परिभाषित करता है जिस पर सिस्टम का संचालन निर्भर करता है। और चूंकि प्रत्येक वर्ग किसी का उपवर्ग है, यह व्यवहार आपके द्वारा बनाई गई सभी वस्तुओं से विरासत में मिला है। इसलिए, कोई भी वर्ग एक फ़ंक्शन को परिभाषित करता है जिसे समान कहा जाता है, और इसलिए, यह फ़ंक्शन स्वचालित रूप से सभी ऑब्जेक्ट्स को विरासत में मिला है।
• इसका अर्थ है कि बहुरूपता का उपयोग किसी भी वस्तु के साथ किया जा सकता है। प्रत्येक वर्ग किसी भी का एक उपवर्ग है, इसलिए आपके द्वारा बनाई गई कोई भी वस्तु किसी भी वर्ग को उसके अंतिम रूप के रूप में दर्शाती है। इसका मतलब है कि आप किसी भी पैरामीटर या किसी भी रिटर्न प्रकार के साथ एक फ़ंक्शन बना सकते हैं जो किसी भी प्रकार की वस्तुओं के साथ काम करेगा। इसका मतलब यह भी है कि आप निम्नलिखित फॉर्म के कोड के साथ किसी भी प्रकार की वस्तुओं के भंडारण के लिए बहुरूपी सारणी बना सकते हैं:

 val myArray = arrayOf(Car(), Guitar(), Giraffe()) 

कंपाइलर ने नोटिस किया कि एरे में प्रत्येक ऑब्जेक्ट में किसी भी का एक सामान्य प्रोटोटाइप है, और इसलिए एरे का प्रकार बनाता है।

किसी भी वर्ग को विरासत में मिला सामान्य व्यवहार एक करीब से देखने लायक है।

सामान्य व्यवहार किसी से विरासत में मिला

कोई भी वर्ग प्रत्येक वर्ग द्वारा विरासत में प्राप्त कई कार्यों को परिभाषित करता है। यहाँ बुनियादी कार्यों और उनके व्यवहार के उदाहरण हैं:

• बराबरी (कोई: कोई भी): बूलियन
  जाँच करता है कि क्या दो वस्तुओं को "समान" माना जाता है। डिफ़ॉल्ट रूप से, फ़ंक्शन सही हो जाता है यदि इसका उपयोग किसी ऑब्जेक्ट को जांचने के लिए किया जाता है, या विभिन्न वस्तुओं के लिए गलत -। दृश्यों के पीछे, समान फ़ंक्शन को हर बार == ऑपरेटर प्रोग्राम में उपयोग किया जाता है।

 val w1 = Wolf() val w1 = Wolf() val w2 = Wolf() val w2 = w1 println(w1.equals(w2)) println(w1.equals(w2)) false (equals  false, true (equals  true,   w1  w2   w1  w2        .)      —   ,   w1 == w2. 

• हैशकोड (): इंट
  किसी ऑब्जेक्ट के लिए हैश कोड देता है। हैश कोड का उपयोग अक्सर कुछ डेटा संरचनाओं द्वारा कुशलतापूर्वक स्टोर और पुनः प्राप्त करने के लिए किया जाता है।

 val w = Wolf() println(w.hashCode()) 

523429237 (हैश कोड w का मूल्य)

• .String (): स्ट्रिंग
  ऑब्जेक्ट का प्रतिनिधित्व करने वाला स्ट्रिंग संदेश लौटाता है। डिफ़ॉल्ट रूप से, संदेश में वर्ग का नाम और एक नंबर होता है, जिसकी हम आमतौर पर परवाह नहीं करते हैं।

 val w = Wolf() println(w.toString()) 

भेड़िया @ 1f32e575

डिफ़ॉल्ट रूप से, समान फ़ंक्शन जाँचता है कि क्या दो ऑब्जेक्ट एक ही वास्तविक ऑब्जेक्ट हैं।

बराबर फ़ंक्शन == ऑपरेटर के व्यवहार को निर्धारित करता है।

कोई भी वर्ग सूचीबद्ध सभी कार्यों के लिए एक डिफ़ॉल्ट कार्यान्वयन प्रदान करता है, और ये कार्यान्वयन सभी वर्गों द्वारा विरासत में मिले हैं। हालाँकि, आप सभी सूचीबद्ध फ़ंक्शंस के डिफ़ॉल्ट व्यवहार को बदलने के लिए इन कार्यान्वयनों को ओवरराइड कर सकते हैं।

दो वस्तुओं की सरल तुल्यता जाँच

कुछ स्थितियों में, आपको == ऑपरेटर के व्यवहार को बदलने के लिए समान फ़ंक्शन के कार्यान्वयन को बदलने की आवश्यकता है।

मान लीजिए कि आपके पास एक नुस्खा वर्ग है जो आपको व्यंजनों को संग्रहीत करने के लिए ऑब्जेक्ट बनाने की अनुमति देता है। ऐसी स्थिति में, आपको दो रेसिपी वस्तुओं के बराबर (या समतुल्य) पर विचार करने की संभावना है यदि उनमें एक ही नुस्खा का विवरण हो। मान लीजिए कि रेसिपी क्लास को दो गुणों के साथ परिभाषित किया गया है - शीर्षक और इज़वेटेरियन:

 class Recipe(val title: String, val isVegetarian: Boolean) { } 

== ऑपरेटर एक ही गुण, शीर्षक और isVegetarian के साथ दो पकाने की विधि की तुलना करने के लिए उपयोग किया जाता है, तो यह सच हो जाएगा।

 val r1 = Recipe("Chicken Bhuna", false) val r2 = Recipe("Chicken Bhuna", false) 

यद्यपि आप बराबर फ़ंक्शन को ओवरराइड करने के लिए अतिरिक्त कोड लिखकर == ऑपरेटर के व्यवहार को बदल सकते हैं, कोटलिन डेवलपर्स ने अधिक सुविधाजनक समाधान प्रदान किया है: उन्होंने एक डेटा वर्ग की अवधारणा बनाई। आइए देखें कि ये वर्ग क्या हैं और ये कैसे बनाए जाते हैं।

डेटा वर्ग आपको डेटा ऑब्जेक्ट बनाने की अनुमति देता है।

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

डेटा वर्ग को परिभाषित करने के लिए, डेटा कीवर्ड के साथ सामान्य डेटा परिभाषा को प्राथमिकता दें। निम्न कोड डेटा वर्ग के लिए पहले बनाई गई रेसिपी क्लास को परिवर्तित करता है:

 data class Recipe(val title: String, val isVegetarian: Boolean) { } 

डेटा उपसर्ग एक नियमित वर्ग को डेटा वर्ग में परिवर्तित करता है।

डेटा क्लास के आधार पर ऑब्जेक्ट कैसे बनाएं

डेटा क्लास ऑब्जेक्ट्स को नियमित क्लास ऑब्जेक्ट्स के समान बनाया जाता है: इस क्लास के कंस्ट्रक्टर को कॉल करके। उदाहरण के लिए, निम्न कोड एक नया नुस्खा डेटा ऑब्जेक्ट बनाता है और इसे r1 नामक एक नए चर में असाइन करता है:

 val r1 = Recipe("Chicken Bhuna", false) 

डेटा कक्षाएं स्वचालित रूप से == ऑपरेटर के व्यवहार को बदलने के लिए उनके समान कार्यों को ओवरराइड करती हैं ताकि प्रत्येक वस्तु के संपत्ति मूल्यों के आधार पर वस्तुओं की समानता की जांच की जा सके। यदि, उदाहरण के लिए, आप एक ही गुण मान के साथ दो रेसिपी ऑब्जेक्ट बनाते हैं, तो == ऑपरेटर के साथ दो ऑब्जेक्ट्स की तुलना करने से परिणाम सही होगा, क्योंकि एक ही डेटा उनमें संग्रहीत है:

 val r1 = Recipe("Chicken Bhuna", false) val r2 = Recipe("Chicken Bhuna", false) //r1 == r2  true 

r1 और r2 को "समान" माना जाता है क्योंकि दो रेसिपी वस्तुओं में समान डेटा होता है।

सुपरक्लास एनी, डेटा वर्गों से विरासत में मिले समान फंक्शन के नए कार्यान्वयन के अलावा
हैशकोड और स्ट्रींग फ़ंक्शन को भी ओवरराइड करें। आइए देखें कि इन कार्यों को कैसे लागू किया जाता है।

क्लास ऑब्जेक्ट उनके विरासत वाले व्यवहार को फिर से परिभाषित करते हैं

डेटा के साथ काम करने के लिए, एक डेटा वर्ग को वस्तुओं की आवश्यकता होती है, इसलिए यह स्वचालित रूप से समतुल्य, हैशकोड और किसी भी सुपरक्लास से विरासत में प्राप्त कार्यों के लिए निम्नलिखित कार्यान्वयन प्रदान करता है:

समान कार्य गुण मानों की तुलना करता है

जब एक डेटा वर्ग को परिभाषित करते हैं, तो इसके बराबर फ़ंक्शन (और इसलिए == ऑपरेटर) अभी भी सही है अगर लिंक उसी ऑब्जेक्ट को इंगित करते हैं। लेकिन यह भी सच है कि यदि वस्तुओं में समान गुण मान हैं जो निर्माता में परिभाषित हैं:

 val r1 = Recipe("Chicken Bhuna", false) val r2 = Recipe("Chicken Bhuna", false) println(r1.equals(r2)) true 

डेटा ऑब्जेक्ट को समान माना जाता है यदि उनके गुणों में समान मूल्य होता है।

समान वस्तुओं के लिए, समान हैशकोड मान वापस किए जाते हैं

यदि दो डेटा ऑब्जेक्ट को समान माना जाता है (दूसरे शब्दों में, उनके पास समान संपत्ति मूल्य हैं), हैशकोड फ़ंक्शन इन ऑब्जेक्ट्स के लिए समान मान लौटाता है:

 val r1 = Recipe("Chicken Bhuna", false) val r2 = Recipe("Chicken Bhuna", false) println(r1.hashCode()) println(r2.hashCode()) 

241131113
241131113

.String सभी गुणों का मान लौटाता है

अंत में, स्टर्लिंग फ़ंक्शन अब क्लास का नाम नहीं देता है, उसके बाद एक नंबर आता है, लेकिन डेटा क्लास के कंस्ट्रक्टर में परिभाषित सभी गुणों के मूल्यों के साथ एक उपयोगी स्ट्रिंग देता है:

 val r1 = Recipe("Chicken Bhuna", false) println(r1.toString()) Recipe(title=Chicken Bhuna, isVegetarian=false) 

किसी भी सुपरक्लास से विरासत में मिले कार्यों को ओवरराइड करने के अलावा, डेटा वर्ग अतिरिक्त टूल भी प्रदान करता है जो डेटा के साथ अधिक कुशल कार्य प्रदान करता है, उदाहरण के लिए, डेटा ऑब्जेक्ट्स की प्रतिलिपि बनाने की क्षमता। आइए देखें कि ये उपकरण कैसे काम करते हैं।

कॉपी फंक्शन के साथ डाटा ऑब्जेक्ट कॉपी करना

यदि आपको इसके कुछ गुणों को बदलकर डेटा ऑब्जेक्ट की प्रतिलिपि बनाने की आवश्यकता है, लेकिन अन्य गुणों को उनके मूल स्थिति में छोड़ दें, तो कॉपी फ़ंक्शन का उपयोग करें। ऐसा करने के लिए, फ़ंक्शन को उस ऑब्जेक्ट के लिए कहा जाता है जिसे आप कॉपी करना चाहते हैं, और नए मूल्यों के साथ सभी उत्परिवर्तनीय गुणों के नाम इसके पास जाते हैं।

मान लें कि आपके पास r1 नाम की एक रेसिपी वस्तु है, जिसे इस तरह कोड में परिभाषित किया गया है:

 val r1 = Recipe("Thai Curry", false) 

यदि आप Recipe ऑब्जेक्ट की एक प्रति बनाना चाहते हैं, तो isegetarian property की value को true के साथ प्रतिस्थापित करें, यह इस प्रकार किया जाता है:


संक्षेप में, इसका अर्थ है "r1 ऑब्जेक्ट की एक प्रति बनाएं, अपनी isegetarian प्रॉपर्टी के मूल्य को सही में बदलें, और r2 नामक एक वैरिएबल पर एक नई ऑब्जेक्ट असाइन करें।" इससे ऑब्जेक्ट की एक नई प्रतिलिपि बनाई जाती है, और मूल ऑब्जेक्ट अपरिवर्तित रहता है।

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

डेटा कक्षाएं घटक ... कार्यों को परिभाषित करती हैं

डेटा वर्ग को परिभाषित करते समय, कंपाइलर स्वचालित रूप से क्लास में उन फ़ंक्शन का एक सेट जोड़ता है, जिन्हें संपत्ति मान तक पहुंचने के लिए वैकल्पिक तंत्र के रूप में उपयोग किया जा सकता है। इन कार्यों को कंपोनेंट फ़ंक्शंस के सामान्य नाम के तहत जाना जाता है, जहाँ N को पुनः घोषित किए जाने वाले गुणों की संख्या है (घोषणा क्रम में)।

यह देखने के लिए कि घटक कैसे काम करता है, मान लें कि आपके पास निम्नलिखित पकाने की विधि है:

 val r = Recipe("Chicken Bhuna", false) 

यदि आप ऑब्जेक्ट की पहली संपत्ति (टाइटल प्रॉपर्टी) का मूल्य प्राप्त करना चाहते हैं, तो आप इसके लिए घटक 1 () फ़ंक्शन को कॉल कर सकते हैं:

 val title = r.component1() 

घटक 1 () उस संदर्भ को लौटाता है जो डेटा क्लास के कंस्ट्रक्टर में परिभाषित पहली संपत्ति में निहित है।

फ़ंक्शन निम्न कोड के समान है:

 val title = r.title 

फ़ंक्शन के साथ कोड अधिक सार्वभौमिक है। कॉम्पोनेंटन फ़ंक्शन डेटा कक्षाओं में इतने उपयोगी क्यों हैं?

... डेटा ऑब्जेक्ट्स का पुनर्गठन करने के लिए डिज़ाइन किया गया

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

मान लीजिए कि आप एक पकाने की विधि के गुणों के मूल्यों को लेना चाहते हैं और इसके प्रत्येक गुण के मूल्य को एक अलग चर में निर्दिष्ट करते हैं। कोड के बजाय

 val title = r.title val vegetarian = r.isVegetarian 

प्रत्येक संपत्ति के अनुक्रमिक प्रसंस्करण के साथ, आप निम्नलिखित कोड का उपयोग कर सकते हैं:

 val (title, vegetarian) = r 

पहली संपत्ति को शीर्षक आर और शाकाहारी को दूसरी संपत्ति को सौंपता है।

इस कोड का अर्थ है "दो चर, शीर्षक और शाकाहारी बनाएं, और प्रत्येक चर के r गुणों में से एक का मान निर्दिष्ट करें।" वह अगले टुकड़े के रूप में ही करता है

 val title = r.component1() val vegetarian = r.component2() 

लेकिन यह अधिक कॉम्पैक्ट निकला।

=== ऑपरेटर हमेशा जाँचता है कि क्या दो चर एक ही वस्तु को संदर्भित करते हैं।

यदि आप यह जांचना चाहते हैं कि क्या दो चर उनके प्रकार की परवाह किए बिना एक ही वस्तु को संदर्भित करते हैं, तो == के बजाय === ऑपरेटर का उपयोग करें। === ऑपरेटर परिणाम देता है अगर (और केवल अगर) दो चर एक वास्तविक वस्तु का एक संदर्भ होता है तो सच है। यदि आपके पास दो चर, x और y, और निम्न अभिव्यक्ति है:

 x === y 

परिणाम सत्य है, तो आप जानते हैं कि चर x और y को एक ही वस्तु को संदर्भित करना चाहिए।

== ऑपरेटर के विपरीत, === ऑपरेटर का व्यवहार समान फ़ंक्शन से स्वतंत्र है। === ऑपरेटर हमेशा वर्ग के प्रकार की परवाह किए बिना समान व्यवहार करता है।

अब जब आपने डेटा कक्षाएं बनाना और उनका उपयोग करना सीख लिया है, तो रेसिपी कोड के लिए एक प्रोजेक्ट बनाएं।

रेसिपी प्रोजेक्ट बनाना

JVM के लिए एक नया Kotlin प्रोजेक्ट बनाएं और इसे "रेसिपी" नाम दें। फिर एक नया बनाएँ
कोटलिन फ़ाइल, जिसका नाम Recipes.kt है: src फ़ोल्डर का चयन करें, फ़ाइल मेनू खोलें और कमांड चुनें
नई → कोटलिन फ़ाइल / कक्षा। फ़ाइल का नाम "रेसिपी" दर्ज करें और किंडल समूह में फ़ाइल विकल्प चुनें।

हम रेसिपी नामक प्रोजेक्ट में एक नया डेटा क्लास जोड़ते हैं और रेसिपी डेटा ऑब्जेक्ट बनाते हैं। नीचे कोड है। रेसिपी के अपने संस्करण को अपडेट करें। इसे हमारे साथ लाइन में लाएं:

 data class Recipe(val title: String, val isVegetarian: Boolean) (  {} ,        .) fun main(args: Array<String>) { val r1 = Recipe("Thai Curry", false) val r2 = Recipe("Thai Curry", false) val r3 = r1.copy(title = "Chicken Bhuna") (  r1    title) println("r1 hash code: ${r1.hashCode()}") println("r2 hash code: ${r2.hashCode()}") println("r3 hash code: ${r3.hashCode()}") println("r1 toString: ${r1.toString()}") println("r1 == r2? ${r1 == r2}") println("r1 === r2? ${r1 === r2}") println("r1 == r3? ${r1 == r3}") val (title, vegetarian) = r1 ( r1) println("title is $title and vegetarian is $vegetarian") } 

जब आप अपना कोड चलाते हैं, तो निम्न पाठ IDE के आउटपुट विंडो में दिखाई देगा:

 r1 hash code: -135497891 r2 hash code: -135497891 r3 hash code: 241131113 r1 toString: Recipe(title=Thai Curry, isVegetarian=false) r1 == r2? true r1 === r2? false r1 == r3? false title is Thai Curry and vegetarian is false 

»पुस्तक की अधिक जानकारी प्रकाशक की वेबसाइट पर पाई जा सकती है
» सामग्री
» अंश

खाबरोजिटेल के लिए कूपन पर 25% की छूट - कोटलिन

पुस्तक के पेपर संस्करण के भुगतान पर, एक इलेक्ट्रॉनिक पुस्तक ई-मेल द्वारा भेजी जाती है।