उद्देश्य-सी पहली प्रोग्रामिंग भाषा के रूप में

कुछ स्पष्ट सवालों के स्पष्ट जवाब नहीं मिलने के बाद इस पोस्ट की कल्पना की गई थी। मैं एक शांत प्रोग्रामर होने का नाटक नहीं करता। नहीं, अभी भी आगे है, लेकिन हैचिंग की अवधि पहले ही बीत चुकी है। यह लेख श्रृंखला से है "पता नहीं यह कैसे करना है अपने आप को - दूसरे को सिखाना।" मेरा मतलब है, कुछ बेहतर समझने के लिए, आपको किसी को कुछ समझाने की जरूरत है। मोपेड मेरा नहीं है, यह वाक्यांश मुझे पहले हाबे के प्रकाशनों में मिला था। कुछ चीजों को समझना बहुत कठिन है। और जो लोग समझते हैं वे आमतौर पर एक शुरुआत करने वाले को नहीं समझा सकते हैं। शायद इसका भी मुझे इंतजार है। यह एक वयस्क और बच्चे के बीच बातचीत की तरह है। लगभग एक पीढ़ीगत संघर्ष। जब तक मेरा स्तर एक पेशेवर में नहीं बढ़ जाता है, मुझे अपनी वर्तमान दृष्टि को बताने की आवश्यकता है।

लेख में, विभिन्न अवधारणाओं को समझाने के लिए उपयोग किए जाने वाले शब्द उद्धृत किए गए हैं। लेख उन लोगों के लिए लिखा गया है जो पहले से ही लूप और सरणियों के बीच अंतर करना सीख चुके हैं और समझते हैं कि एक फ़ंक्शन और विधि क्या है।
यदि आपने कभी प्रोग्राम नहीं किया है, तो केर्निगन और रिची (किसी भी संस्करण में) की पुस्तक, आप स्पष्ट रूप से नहीं कर पाएंगे। प्रकृति में, ऐसी कोई इच्छाशक्ति नहीं है जो उपरोक्त सभी समस्याओं को हल करते हुए आपको पुस्तक को अंत तक पढ़ने के लिए मजबूर कर सके।
मैं अत्यधिक BecAnXcoder की सलाह देता हूं। सब कुछ लिखा गया है जो उन लोगों के लिए पर्याप्त स्पष्ट है जो प्रोग्रामिंग के बारे में बहुत कम जानते हैं। जानकारी थोड़ी पुरानी है, लेकिन यह एक शुरुआत के लिए करेगी। हो सकता है कि आपने पहले से ही अपनी आंख को पकड़ा हो या आपने इसे डाउनलोड भी किया हो, लेकिन इसे साहित्य के साथ एक कैटलॉग में डाल दें (अच्छी तरह से, हर किसी के पास इस तरह का एक कैटलॉग है, यह दसियों गीगाबाइट लेता है और हम यह सब पढ़ने के लिए जा रहे हैं जैसे ही खाली समय दिखाई देता है, और कैटलॉग बढ़ता है ... )।
यह स्पष्ट है कि सबसे अच्छा विकल्प मैक है। सबसे खराब, एक हैकिंटोश या वर्चुअल मशीन। और यहां तक ​​कि अगर प्रोसेसर आपको उपरोक्त में से कोई भी शुरू करने की अनुमति नहीं देता है, तो आप कमांड लाइन में बाद के संकलन के साथ नोटबुक में सही शुरू कर सकते हैं।
कई मंचों में, आप एक लोकप्रिय प्रश्न उन लोगों द्वारा पा सकते हैं, जो स्पष्ट रूप से एक भारी बख्तरबंद टैंक में हैं: "क्या उद्देश्य-सी प्रोग्रामर को वास्तविक सी सीखने की आवश्यकता है?" हर जगह वे एक ही बात लिखते हैं। जो लोग अधिक दाढ़ी वाले होते हैं और संरचित प्रोग्रामिंग के साथ शुरू होते हैं - वे कहते हैं कि आपको सी में कम से कम मिडिलडेवलपर बनने की आवश्यकता है, और उसके बाद ही ओओपी के भयंकर विकलों में रास्ता खोजिए, जो कि ऑब्जेक्टिव-सी है। जो लोग सी को नहीं जानते थे, लेकिन पहले से ही किसी तरह मिडडेवलपर स्थिति तक पहुंच चुके थे, वस्तु: वे कहते हैं, जानें कि iPhone पर बटन कैसे खींचे जाते हैं और उन्हें एक फ़ंक्शन कैसे असाइन किया जाता है, और आवश्यक होने पर मैटरिल को फिर से कड़ा कर दिया जाएगा। मैं स्पष्ट रूप से घोषणा करता हूं कि यह जानने के लिए कि बटन को कैसे कार्य सौंपे गए हैं, कोई प्रोग्रामिंग नहीं है! मैं आपको शुद्ध सी समझने में छह महीने खर्च करने का आग्रह नहीं करता हूं। लेकिन कुछ हफ़्ते - एक महीने के लायक है। यह आपकी महत्वाकांक्षाओं को कुछ पृष्ठभूमि देगा। जैसा कि आप सीखते हैं, पहले से ही ऑब्जेक्टिव-सी में आवश्यक रूप से ऐसी कोड संरचनाएं होंगी जो स्पष्ट नहीं होंगी। इसलिए, मैं बिना किसी कट्टरता के प्रस्ताव करता हूं, लेकिन कृपनिक ए.बी. द्वारा पुस्तक को विस्तार से पढ़ने के लिए। "लर्निंग सी"। यह वॉल्यूम में पिछले एक से 3 गुना बड़ा है, लेकिन आसानी से और स्वाभाविक रूप से पढ़ा जाता है। पुस्तक फिर से, काफी सस्ती स्तर पर, प्रोग्रामिंग के मूल तत्वों की व्याख्या करती है। इसमें, आप सीख सकते हैं कि एक लूप से एक सरणी को कैसे अलग किया जाए और संकेत क्या हैं।
हाल ही में, एक लेख Habré पर प्रकाशित हुआ, जहां लेखक ने साहित्य का एक गुच्छा दिया, जिसे उन्होंने पढ़ने और रोटी के लिए कनिष्ठ के रूप में काम करने की सलाह दी। यदि आप बस उस लेख में उद्धृत सभी साहित्य को पढ़ते हैं, तो आप कुछ भी नहीं सीखेंगे, और यदि आप सभी साहित्य को फिर से परिभाषित और याद कर सकते हैं, तो आप एक जूनियर के रूप में नहीं, बल्कि एक प्रतिष्ठित डेवलपर के रूप में जाने में सक्षम होंगे।

प्रारंभ: वर्ग विधि और उदाहरण विधि

एक विधि क्या है? यह आदेशों / निर्देशों या एक आदेश / निर्देश का एक सेट है जिसे किसी वस्तु पर लागू किया जा सकता है और इसमें आवश्यक प्रक्रियाओं को लागू किया जा सकता है। यदि यह पूरी तरह से स्पष्ट नहीं है, तो पढ़ें और समझें। वास्तव में यह समझना कठिन है कि कक्षा विधि और आवृत्ति विधि क्या है। हर कोई कहता है: "के साथ" + "चिन्ह वर्ग विधि है, लेकिन" - "संकेत उदाहरण विधि है। क्या यह स्पष्ट है? "और जवाब में वे सुनते हैं:" हाँ, वर्ग विधि और उदाहरण विधि। " सबसे पहले, मैंने व्यक्तिगत रूप से केवल यह समझा कि वे अलग-अलग थे, लेकिन क्या और कब लागू करना अस्पष्ट रहा। विकिपीडिया हठपूर्वक वही बात दोहराता है जो हमने सुनी और पढ़ी है।
अधिकांश मामलों में, आप उदाहरण के तरीकों से काम करेंगे।
तो, उदाहरण विधि। कल्पना कीजिए कि हमारे पास एक कार्यक्रम है जिसमें हम 2 वर्गों का उपयोग करेंगे: प्राइमस और रसोई।
किसी भी वर्ग (सार को छोड़कर) के तरीके और / या कार्य हैं। एक कक्षा में एक विधि नाम (वर्ग विधि) के सामने "+" चिन्ह के साथ कई विधियाँ हो सकती हैं और एक विधि नाम (उदाहरण विधि) के सामने एक "-" चिन्ह के साथ कई विधियाँ होती हैं। ये वे विधियाँ हैं जिनका उपयोग हम "-" वस्तुओं के संबंध में करते हैं - वर्ग और स्वयं वर्ग के उदाहरण। और "+" चिह्न वाली विधियाँ केवल उसी वर्ग के लिए लागू की जा सकती हैं, जहाँ यह विधि घोषित की गई थी।

एक वर्ग का एक उदाहरण क्या है?

यह गर्व, लेकिन समझ से बाहर लगता है। स्कूल के पाठ्यक्रम से कौन याद रखता है: ज्यामिति में, एक बिंदु एक वृत्त, एक रेखा और अन्य आकृतियों के लिए एक माता-पिता है, क्योंकि प्रत्येक आकृति में कई बिंदु होते हैं।
उद्देश्य-सी के लिए एक वर्ग, कुछ संसाधनों पर एक वस्तु के रूप में व्याख्या की गई और इसके विपरीत। वास्तव में यह इस तरह से एक छोटा सा है। हम कह सकते हैं कि एक वस्तु एक वर्ग का एक उदाहरण है। आपकी रसोई में प्राइमस के एक ठोस उदाहरण के रूप में, यह प्राइमस प्रकार का नमूना है: ट्विस्ट, बर्नर, आदि के साथ। यह सिर्फ प्राइमस नहीं है - यह आपका प्राइमस है। एक वर्ग का अनुसरण करने के लिए एक उदाहरण है। किसी चीज़ का एक संदर्भ नमूना, जो कक्षा के तरीकों ("+" चिह्न के साथ) के लिए कुछ फ़ंक्शन का धन्यवाद कर सकता है। यहां आप थोड़ा और विस्तृत पढ़ सकते हैं।
"प्रोटोकॉल" और "अमूर्त वर्ग" भी हैं। यहां सब कुछ अधिक दिलचस्प है, लेकिन समझ की दहलीज एक वर्ग और एक वस्तु से अधिक है। अंतर यह है कि एक "प्रोटोकॉल" में एक उपवर्ग या कोई बच्चा वस्तु नहीं हो सकती है, जिससे उसे मिलान करना होगा। नौकरी के लिए आवेदन करते समय आवश्यकता के रूप में। वास्तविक जीवन में प्रोटोकॉल का अनुप्रयोग मैं इस लेख में स्पर्श करूंगा। एक अमूर्त वर्ग एक इकाई है जो जैसा है, वह एक वर्ग था, लेकिन बहुत ठोस वर्ग नहीं है, और इसलिए सार। उदाहरण के लिए, फिर से, आपका होम प्राइमस प्राइमस वर्ग का एक उदाहरण है, न कि कुछ अमूर्त हीटर वर्ग। आपके पास एक कबीले और जनजाति के बिना घर में हीटर नहीं हो सकता है (यह एक चिमनी और बैटरी भी हो सकती है)। इस तरह, क्लास "प्राइमस" - अमूर्त वर्ग "हीटिंग डिवाइस" का उत्तराधिकारी हो सकता है। और आपका प्राइमस पहले से ही प्राइमस की एक विशिष्ट परिभाषा का एक उदाहरण है। और उसकी विशेषताओं के लिए - गुण, विधियाँ, प्रोटोकॉल, इसका उपयोग करते समय, वह अपनी कक्षा में जाता है और जाँचता है कि वह क्या कर सकता है, वह क्या नहीं कर सकता है और सामान्य रूप से क्या हो सकता है।
कल्पना कीजिए कि एक निश्चित वर्ग "गैस बर्नर" है - सार वर्ग "हीटिंग डिवाइस" का उत्तराधिकारी। कक्षा "गैस बर्नर" "प्राइमस" और "गैस स्टोव" के लिए माता-पिता होंगे। प्रोग्रामिंग के करीब आने के लिए, आपको थोड़ा सार करने की आवश्यकता है।
ऑब्जेक्टिव-सी में पैरेंट क्लास, NSObject है। एक प्रोग्रामिंग भाषा में, यह ज्यामिति में एक बिंदु की तरह है। यह एक आदर्श वर्ग है: इसमें कुछ भी शानदार नहीं है, यह कुछ भी ठोस नहीं करता है, लेकिन आप इससे कुछ भी बना सकते हैं। इस तरह ब्रह्मांड की ईंट है। यदि Xcode में आप कमांड बटन दबाए रखते हैं और NSObject पर क्लिक करते हैं, तो NSObject.h फ़ाइल की सामग्री आपके सामने खुल जाएगी। इसमें विभिन्न विधियों के विवरण की लगभग 200 लाइनें हैं। नाम के सामने "+" चिह्न के साथ दोनों विधियां हैं, साथ ही साथ "-" चिन्ह वाली विधियां भी हैं। "+" चिह्न के साथ विधियों का सार यह है कि वे केवल सीधे NSObject पर ही लागू किए जा सकते हैं। यह विधि है, उदाहरण के लिए,

+(id) alloc; 

और आप इसे केवल इस तरह से लागू कर सकते हैं:

 [NSObject alloc]; 

ऑब्जेक्टिव-सी में कोई अन्य वस्तु, परिभाषा के अनुसार, NSObject का वंशज है। यह अतिरिक्त तरीकों को लागू करता है जो इसे व्यक्तित्व लक्षण देते हैं। मान लीजिए कि यह एक NSResponder है। यह वंशज, NSResponder के भी बच्चे हो सकते हैं। उदाहरण के लिए UIView। विरासत के पेड़ के साथ, आप एक उदाहरण के रूप में UIScrollView ले सकते हैं। फिर - UITableView। प्रत्येक मामले में, वंशज अतिरिक्त कार्यक्षमता के साथ आगे निकल जाते हैं। इस तथ्य के अलावा कि वे अपने स्वयं के, व्यक्तिगत कुछ कर सकते हैं, वे वह सब कुछ कर सकते हैं जो उनके पूर्वज कर सकते हैं। यह विरासत है ।
यदि आप नहीं चाहते हैं कि आपका बच्चा कक्षा मूल कक्षा के व्यवहार की नकल करे, तो आप अपनी पसंद के हिसाब से मूल कक्षा की किसी भी विधि को फिर से कर सकते हैं। यह बहुरूपता है ।
अपने कार्यक्रमों में, आप अपनी आवश्यकता के अनुसार कक्षा लेंगे और उसमें आवश्यक तरीके जोड़ेंगे - इसकी कार्यक्षमता का विस्तार करेंगे। आप अपने द्वारा बनाई गई कक्षा भी ले सकते हैं और इसे एक वंशज बना सकते हैं, फिर से कार्यक्षमता का विस्तार कर सकते हैं और साथ ही वांछित समस्या को हल करने के लिए एक अनूठा उपकरण बना सकते हैं। वर्णित तंत्र को कहा जाता है - "उपवर्ग" के उपवर्गों का निर्माण।
मैं "+" संकेत के साथ तरीकों के व्यापक विवरण में नहीं जाऊंगा। यह स्पष्ट हो जाएगा कि विधि का आवेदन

 +(id) alloc; 

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

 NSObject *object = [NSObject alloc]; 

विधि आवेदन

 -(id) init; 

ऑब्जेक्ट को इनिशियलाइज़ करता है, रैम में इसके लिए जगह आवंटित करता है और वास्तव में उसके बाद ऑब्जेक्ट मौजूद होना शुरू होता है और आप इसके साथ काम कर सकते हैं।

 NSObject *object = [[NSObject alloc] init]; 

इन 2 विधियों ("आवंटित" और "init") ने केवल एक ऑब्जेक्ट बनाया है। और यह ऑब्जेक्ट किसी ऑब्जेक्ट का उदाहरण या NSObject क्लास का एक उदाहरण है। यदि आप इन तरीकों को अलग से लागू करते हैं

 NSObject *object = [NSObject alloc]; [object init]; 

फिर ऑब्जेक्ट भी बनाया जाएगा। लेकिन एक गैर-शून्य संभावना है कि आप उस गलत वस्तु का निर्माण करेंगे जिसके लिए मेमोरी आवंटित की गई थी। चलिए एक विधि कहते हैं

 NSObject *object = [NSObject alloc]; 

उसके लिए स्मृति में एक ऐसा पता आवंटित किया गया है

 0x000000000 

ऐसा इसलिए होता है क्योंकि आरंभीकरण के दौरान, रनटाइम वातावरण सभी वस्तुओं को "कचरा" से भर देता है, ताकि "कचरा" से भरी स्मृति में एक जगह को संदर्भित करने से बचें। या किसी अन्य विशिष्ट वस्तु से लिंक करता है, जो वास्तव में "कचरा" भी है, क्योंकि यह अपना जीवन चक्र पूरा कर चुका है और अब मेमोरी में "संग्रहीत" नहीं है, लेकिन बस "स्थित" है। यह समझने के लिए कि "कचरा" क्या है, एक साधारण कार्यक्रम बनाएं जिसमें आप घोषणा करते हैं

 int i; 

इसके लिए एक मान निर्दिष्ट किए बिना, और फिर इसके मूल्य को कंसोल पर आउटपुट करें

 NSLog(@"%i", i); 

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

 if (!self){ ... } 

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

 NSObject *object = [[NSObject alloc] init]; 

तब "बिंगो!", और वस्तु आप की है, इसके साथ आप जो चाहें कर सकते हैं। लेकिन अगर आप इस पर विधि लागू करते हैं

 [object init]; 

तब किसी अन्य ऑब्जेक्ट को प्रारंभ किया जा सकता है। ऐसा लगता है कि आपने एक कार के लिए ऋण का भुगतान किया है, लेकिन यह पता चला है कि यह उस कार के लिए नहीं था और वे आपको एक कार के बजाय दूसरा देते हैं। वे पहली नज़र में एक दूसरे से अलग नहीं हैं। लेकिन उनके पास अलग-अलग "VIN" नंबर होते हैं, जिसका अर्थ है कि "GAI" पोस्ट पर चेक करते समय आपको सूचित किया जाएगा कि कार आपकी नहीं है। इस घटना का एक और स्पष्टीकरण नीचे दिया जाएगा।
जैसा कि आप पहले से ही समझते हैं, "+ आबंटित" विधि एक वर्ग विधि है, और "-init" विधि एक उदाहरण विधि है।
मैं वास्तविक चीजों के साथ एक उदाहरण दूंगा।
विधि के पूर्ण कार्यान्वयन में आमतौर पर एक्सटेंशन * .h और * .m के साथ 2 फाइलें शामिल हैं। अन्य संख्याएं हैं, यह इस पर निर्भर करता है कि यह किस तरह का वर्ग है और यह किस लक्ष्य का पीछा करता है।
आपके कार्यक्रम में "प्राइमस" का एक वर्ग है। "Primus.h" फ़ाइल में विधियाँ घोषित की गई हैं:

 Primus. h // ,      "Primus" +(Primus *) hotAsHell; // ,    "Primus" -(id) initWithGas:(Gas *)gas temperature:(NSInteger)t; // ,    -(void) doFireWithGas:(Gas *)gas; // ,      ,      -(MasterPoRemontu *) masterPoRemontuWithServiceItems:(NSArray *)i serviceSkills:(NSArray *)s; 

कार्यक्रम में "किचन" वर्ग भी है, जहाँ तरीकों को "किचन.ह" फ़ाइल में घोषित किया गया है:

 Kitchen.h // ,    "Kitchen"      "Kitchen" +(Kitchen *) kitchenFurniture:(NSArray *)furniture otherDishes:(NSArray *)dish; // ,         -(UkrainianBorsch *) borschWithIngredients:(NSarray)ingredients casserolAndPan:(NSArray)pan; 

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

 #import "Primus.h" 

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

  #import "Primus.h" 

। कार्यक्रम के अन्य हिस्सों के लिए तरीकों और चर की दुर्गमता को कहा जाता है - इनकैप्सुलेशन ।

सबसे पहले, रसोई वर्ग के अंदर प्राइमस वर्ग का एक उदाहरण बनाएं

 Primus *myPrimus = [Primus hotAsHell]; 

जैसा कि आप देख सकते हैं, हम c + विधि को myPrimus वर्ग के उदाहरण के लिए नहीं भेज रहे हैं, बल्कि सीधे Primus वर्ग में भेज रहे हैं। MyPrimus नामक प्राइमस वर्ग का एक उदाहरण बनाया गया है। इसके अलावा, साइन के साथ "प्राइमस" से विधियां "-" वर्ग उदाहरण पर लागू होंगी - "मायप्रिमस"। और अगर हम प्राइमस वर्ग का एक नया उदाहरण बनाना चाहते हैं, तो हम फिर से + hotAsHell विधि का उपयोग कर सकते हैं। प्राइमस वर्ग में एक विधि भी है

 -(id) initWithGas:(Gas *)gas temperature:(NSInteger)t; 

आमतौर पर, सभी तरीके जिनका नाम "init" से शुरू होता है, वे NSObject क्लास के "init" तरीके के समान ही करते हैं, लेकिन उन्नत सुविधाओं के साथ। और इस मामले में, इस कोण से "init" विधि का उपयोग किया जाता है

 Primus *myPrimus = [[Primus alloc] initWithGas:Propan temperature:750]; 

अद्वितीय विशेषताओं के साथ प्राइमस वर्ग की एक नई वस्तु बनाएगा।
केवल वर्णित उदाहरण में, तर्कों के साथ एक विधि लागू की गई थी। इस विशेष मामले में, इसका उपयोग स्पष्ट रूप से परिभाषित विशेषताओं के साथ प्राइमस वर्ग का एक उदाहरण बनाने के लिए किया जाता है। विशेषताओं के नाम से पता चलता है कि प्राइमस वर्ग का यह उदाहरण प्रॉपेन प्रकार की गैस और 750 डिग्री के तापमान पर काम करेगा।
ध्यान दें कि ऑब्जेक्टिव-सी में विधियों के नाम बहुत सार्थक हैं। कभी-कभी, आप उनके 10-शब्द नामों से चकित होंगे, लेकिन जो लिखा गया है उसकी बेहतर समझ के लिए यह योगदान देता है। मोटे तौर पर, कोड स्व-दस्तावेजीकरण है। कौन सा पाठ्यक्रम टिप्पणी करने की आवश्यकता को समाप्त नहीं करता है। लेकिन यदि आप इसे अपने तरीके बनाने के लिए एक नियम बनाते हैं, जिसका नाम एक शब्दार्थ लोड होगा और उसी तरह चर के निर्माण से संबंधित होगा, तो कोड में टिप्पणियों की संख्या काफी कम हो सकती है।
ऑब्जेक्टिव-सी में कुछ अन्य प्रोग्रामिंग भाषाओं के विपरीत, तरीकों को नहीं बुलाया जाता है, लेकिन वस्तुओं को भेजा जाता है। इस प्रकार, यह भाषा "संदेश उन्मुख भाषा" को संदर्भित करती है, यह रूसी में बहुत सख्त नहीं है, इसलिए मैं अनुवाद का हवाला नहीं देता।
यह भी ध्यान दें कि एक नया ऑब्जेक्ट बनाने (रिटर्न) में ऑब्जेक्ट भेजने के बाद के सभी तरीके, "+" या "-" के बाद ब्रैकेट्स में हैं या तो ऑब्जेक्ट का विशिष्ट नाम जिसका उदाहरण वे वापस आ जाएंगे, या "आईडी"। अर्थात्, "+" या "-" संकेत के तुरंत बाद कोष्ठक में किस वस्तु को इंगित किया गया है, हम इस विधि को भेजने के बाद क्या प्राप्त करेंगे, इसका अनुमान लगा सकते हैं। एक आईडी क्या है? यह एक प्रकार की वस्तु है जो किसी अन्य वस्तु का रूप (प्रकार) ले सकती है। मान लें कि यह एक "कमजोर" प्रकार की वस्तु है। इस अर्थ में नहीं कि कुछ उसके लिए "कमजोर" है। सामान्य शब्दों में, यह एक कमजोर टाइप की गई वस्तु है। पीएल में ऐसी वस्तुओं की उपस्थिति इसे कमजोर रूप से टाइप करती है।
आप इन ब्रैकेट में "शून्य" प्रकार भी पा सकते हैं।

एक शून्य क्या है?

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

स्व क्या है?

यह शब्द अक्सर कहीं भी उपयोग किया जाता है। विभिन्न स्थानों में इसके आवेदन का तथ्य आपके ज्ञान के सामंजस्यपूर्ण पैंट्री में भ्रम का परिचय देता है।
चलो "प्राइमस" और "किचन" कक्षाओं में लौटते हैं। प्राइमस वर्ग की एक ठोस विधि लें और विचार करें कि प्राइमस.m फाइल में इसका कार्यान्वयन कैसा होगा। उदाहरण के लिए, यह एक विधि है।

 -(void) doFireWithGas:(Gas *)gas; 

इस तरह से लागू किया जा सकता है:

 -(void) doFireWithGas:(Gas *)gas { id myPrimus; if (!self){ myPrimus = [self initWithGas:gas temperature:750]; } ... ... ... } 

घुंघराले कोष्ठक में, विधि का कार्यान्वयन या "निहितार्थ" होता है। इस स्थिति में, विधि का कार्यान्वयन निम्नानुसार पढ़ता है: यदि मायप्रिमस नहीं है, तो कमांड चलाएं

 [self initWithGas:propan temperature:750]; 

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

  id myPrimus; if (!self){ myPrimus = [self initWithGas:gas temperature:750]; } MasterPoRemonty *master = [myPrimus masterPoRemontuWithServiceItems:someItemsArray serviceSkills:someSkillsAray]; } 

और यहां यह पहले से ही स्पष्ट है कि विधि के अंदर कहीं एक प्राइमस मरम्मत विज़ार्ड दिखाई देता है।
विस्मयादिबोधक चिह्न क्यों था "!" "अगर" के बाद कोष्ठक में? प्रोग्रामिंग में, यह नकारात्मकता का संकेत है। वह है, "! =" जैसा लगता है "समान नहीं।" हालत की यह विधि इसकी संक्षिप्तता के लिए सुविधाजनक है। इस उदाहरण में, संरचना में भिन्न स्थिति का उपयोग करना संभव था, जो एक ही कार्य करेगा।

 if (myPrimus == nil){} 

यह स्थिति 2 गुना लंबी है और इसे समझने के लिए आपको पूरी पंक्ति पढ़ने की आवश्यकता है। यह स्थिति छोटी है, लेकिन अगर आपको ऐसा कुछ लिखने की आवश्यकता है

 if ((myPrimus == nil || yourPrimus == nil) && (mamaPrimus == nil || papaPrimus == nil)){} 

फिर यह संरचना

 if ((!myPrimus || !yourPrimus) && (!mamaPrimus || !papaPrimus)){} 

अधिक लाभप्रद स्थिति में होगा, दोनों संक्षिप्तता में और भौतिक आकार में। पिछला निर्माण - यह केवल एक पंक्ति में फिट नहीं हो सकता है।
आइए विचार करें कि "रसोई" वर्ग के ढांचे में इस पद्धति का कार्यान्वयन कैसा दिखेगा। Kitchen.m फाइल में, इस विधि को इस तरह लागू किया जाएगा:

 -(void) doFireWithGas:(Gas *)gas { Primus *myPrimus; if (!myPrimus){ Primus *myPrimus = [Primus initWithGas:gas temperature:750]; } MasterPoRemonty *master = [myPrimus masterPoRemontuWithServiceItems:someItemsArray serviceSkills:someSkillsAray]; ... ... } 

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

 Primus *myPrimus; 

और वर्ग उदाहरण के लिए देखें। एकमात्र चाल यह है कि आपने कुछ भी नहीं बनाया है, और उदाहरण तक पहुंच नहीं है, लेकिन सीधे वर्ग के लिए। स्पष्टता के लिए, मैंने एक ऑब्जेक्ट बनाया

 id myPrimus; 

जिसे विधि से एक्सेस किया जा सकता है। लेकिन इसे बनाना संभव नहीं था, लेकिन एक अधिक जटिल संरचना को लागू करना जो समान कार्य करेगा

  if (!self){ MasterPoRemonty *master = [[self initWithGas:gas temperature:750] masterPoRemontuWithServiceItems:someItemsArray serviceSkills:someSkillsAray]; } 

यह समझने के लिए कि क्या "स्व" लिखना संभव है या नहीं, बस कल्पना करें कि आप किस विधि से किस वस्तु को भेजना चाहते हैं और "आत्म" शब्द लिखना शुरू करते हैं, लेकिन पूरी तरह से नहीं, उदाहरण के लिए, "सेल"। Xcode कई विकल्पों की पेशकश करेगा, जिनमें से वास्तव में "स्वयं" होगा। उसके बाईं ओर यह वर्णन किया जाएगा कि यह किस वर्ग का है। यदि यह वास्तव में वह वर्ग है जिसे आप वांछित विधि (वह वर्ग जिसके भीतर आप वर्तमान में क्रिया कर रहे हैं) को भेजना चाहते हैं, तो "स्व" का उपयोग करें। यदि Xcode इंगित करता है कि "स्व" आपकी आवश्यकता की वस्तु नहीं है, तो उस वर्ग या उदाहरण के नाम का उपयोग करें जिसकी आपको आवश्यकता है।
यह भी स्पष्ट है कि तर्क यहाँ शामिल थे। प्रत्येक तर्क में एक प्रकार होता है, जिसे कोष्ठकों में भी वर्णित किया जाता है, लेकिन बृहदान्त्र के बाद। तर्क के प्रकार के साथ कोष्ठक के बाद तर्क का नाम आता है। यदि तर्क प्रकार के बाद कोष्ठक में "*" चिह्न है, तो यह एक वस्तु है। यदि कोई "*" नहीं है, तो यह एक स्केलर प्रकार है, उदाहरण के लिए, "NSInteger", जो अनिवार्य रूप से एक सरल "int" है। इसके अलावा, "NSInteger" को तर्क के लिए "*" के साथ चिह्नित किया जा सकता है। इस मामले में, हम चर को फिर से नहीं करेंगे, लेकिन इसके लिए एक संकेतक। इंडेक्स का विषय इस लेख के दायरे से परे है। इस विधि में तर्क का नाम

 -(void) doFireWithGas:(Gas *)gas; 

"गैस" की तरह आवाज करेगा। क्या आपने देखा कि कार्यान्वयन में गैस के सामान्य नाम का उपयोग नहीं किया गया था? उदाहरण के लिए, "प्रपॉन"। तथ्य यह है कि तर्क "गैस" में सिर्फ गैस का नाम पारित किया जाता है। कहाँ से? हमने जांच की कि विधि कैसे लागू की जाती है।

 -(void) doFireWithGas:(Gas *)gas; 

इसमें विधि शामिल थी।

 -(id) initWithGas:(Gas *)gas temperature:(NSInteger)t; 

इस पद्धति में 2 तर्क "गैस" और "टी" थे। ऑब्जेक्ट को विधि भेजने में, हमने तापमान का संकेत दिया, और गैस का प्रकार केवल विधि से दोहराया गया

 -(void) doFireWithGas:(Gas *)gas; 

यानी यह विधि भी कहीं भेजी जाती है। आइए विधि पर करीब से नज़र डालें

 (Primus *) hotAsHell; 

इसका क्रियान्वयन इस तरह हो सकता है

 +(Primus *) hotAsHell{ self = [super init]; if (self){ [self doFireWithGas:propanButan]; } return self; } 

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

 -(id) initWithGas:(Gas *)gas temperature:(NSInteger)t; 

इसमें रिटर्न प्रकार, तर्क प्रकार, तर्क और चयनकर्ता शामिल हैं। चयनकर्ता वह विधि है जो लौटे हुए ऑब्जेक्ट के प्रकार, तर्कों के प्रकार और तर्कों को इससे दूर ले जाती है।

 initWithGas:temperature: 

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

सुपर क्या है?

ऊपर लागू की गई hotAsHell विधि पर विचार करें। इसका ऐसा डिज़ाइन है

 self = [super init]; 

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

 [super init]; 

NSObject उदाहरण की init विधि को कॉल करता है। यही है, सभी वस्तुओं के पूर्वज का एक उदाहरण स्वचालित रूप से बनाया जाता है - NSObject, डिफ़ॉल्ट रूप से (विशुद्ध रूप से NSObject के) मापदंडों के साथ। NSObject'y को init मेथड भेजना NSObject से "स्व" देता है। यानी सीधे NSObject का एक उदाहरण। और यह उदाहरण हमारे प्राइमस ऑब्जेक्ट को सौंपा गया है। वास्तव में, इस मामले में "आत्म" ठीक "प्राइमस" है। और इस स्तर पर हमें प्राइमस ऑब्जेक्ट का एक उदाहरण मिलता है, जो NSObject से अलग नहीं है। विधि की हमारी विशेषताएं इसे व्यक्तिगत विशेषताएं देती हैं।

 [self doFireWithGas:propanButan]; 

साथ ही इस वर्ग के ढांचे के भीतर लागू अन्य तरीके।
डिज़ाइन

 if (self) {...} 

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

 ... else {...} 

जहां वे स्थिति को ठीक करने की कोशिश कर रहे हैं, लेकिन, दुर्भाग्य से, यह मामला नहीं है और "और" हमारी मदद नहीं करेगा।
और यहां मैं आपको लेख की शुरुआत से एकतरफा वस्तु की याद दिलाना चाहता हूं। यह अपने सुपरक्लास द्वारा किसी वस्तु के एक उदाहरण के आरम्भ के दौरान है कि स्मृति में एक जगह उसे सौंपी जाती है और एक सूचक को स्मृति में उस स्थान पर स्थानांतरित कर दिया जाता है। और जब हम जाँच करते हैं

 if (self = [super init]) 

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

 if (self) {...} 

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

 return self; 

चूंकि यह विधि "शून्य" नहीं है, इसलिए हमें उम्मीद है कि अंत में हम इसे बताएंगे कि क्या वापस करने की आवश्यकता है। इस मामले में, "प्राइमस" प्रकार की एक वस्तु वापस कर दी जाएगी, क्योंकि इस वर्ग के ढांचे में "स्व" ठीक "प्राइमस" है। इसके अलावा, लौटी हुई वस्तु का प्रकार हमें बताता है कि वास्तव में "प्राइमस" होने की क्या उम्मीद है।
इन विधियों में

 +(Kitchen *) kitchenFurniture:(NSArray *)furniture otherDishes:(NSArray *)dish; -(UkrainianBorsch *) borschWithIngredients:(NSarray)ingredients casserolAndPan:(NSArray)pan; -(MasterPoRemontu *) serviceItems:(NSArray *)i serviceSkills:(NSArray *)s; 

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

वास्तव में दिए गए पैरामीटर क्या हैं?

हम विधि के ऐसे कार्यान्वयन का वर्णन करते हैं

 - (id) initWithGas:(Gas *)gas temperature:(NSInteger)t { ... [self setGas:gas]; [self setTemperature:t]; ... } 

इसका मतलब है कि जब इस विधि को बुलाते हैं

 Primus *myPrimus = [[Primus alloc] initWithGas:metan temperature:500]; 

सचमुच ऐसे पैरामीटर सेट हैं

 [self setGas:metan]; [self setTemperature:500]; 

पैरामीटर वैरिएबल द्वारा निर्धारित किए जाते हैं जो * .h फ़ाइल में घोषित किए जाते हैं।
शब्द "सेटगैस" या "सेटटैन्स" के निर्माण पर ध्यान दें। यदि कोई चर है, उदाहरण के लिए, "चर", तो आप "सेट" उपसर्ग के माध्यम से इसके लिए वांछित मान सेट कर सकते हैं:

 setVariable 

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

 @property (nonatomic, strong) Gas *gas; @property (nonatomic) NSInteger temperature; 

और कार्यान्वयन फ़ाइल में आपको पंजीकरण करना होगा

 @synthesize gas, temperature; 

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

 [myPrimus gas]; [myPrimus temperature]; 

या

 myPrimus.gas; myPrimus.temperature; 

एक टीम के लिए उदाहरण के लिए

 NSLog(@"      %@,   %i", [myPrimus gas], myPrimus.temperature); 

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

 [myPrimus gas]; 

और के माध्यम से

 myPrimus.gas; 

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

 myPrimus.gas; 

इतना

 [myPrimus valueForKey:@"gas"]; 

हमने उस मूल्य के लिए आवेदन किया था जो "गैस" कीवर्ड में "प्राइमस" ऑब्जेक्ट में है।
और इस तरह के एक डिजाइन

 [myPrimus setGas:metan]; 

"की-वैल्यू कोडिंग" के संदर्भ में यह इस तरह दिखेगा

 [myPrimus setValue:@metan forKey:@"gas"]; 

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

क्रम

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

 [myPrimus initWithGas:gelium temperature:nil]; 

सी में "रनटाइम" कुछ इस तरह दिखता है

 objc_msgSend(myPrimus,@selector(initWithGas:temperature:),gelium,nil); 

यह समझने के लिए नौसिखिया कोको प्रोग्रामर के लिए पर्याप्त होना चाहिए: जंगल में आगे नहीं जाना बेहतर है। जैसे ही आप क्लब में प्रवेश की दहलीज को पार करते हैं, आप स्वयं अपनी जरूरत की जानकारी पा सकते हैं।

इस बीच, हम रुचि रखते हैं कि आइसा क्या है।

यह एक चर है जिसे सीधे NSObject में घोषित किया गया है। इसका एकमात्र चर। जब हमने विधि को बुलाया

 [super init]; 

तब न केवल NSobject वर्ग का एक उदाहरण बनाया गया था, बल्कि इस चर "isa" का भी एक उदाहरण था, जो NSOject विषय को संदर्भित करता है। यही है, यह विशेष रूप से रनटाइम बताता है कि यह एक NSObject का है। इसका मतलब है कि आपको अपनी नई बनाई गई वस्तु की तरह ही NSObject के साथ काम करने की आवश्यकता है। पैरेंट ऑब्जेक्ट के लिए एक पॉइंटर जिसे हमें इनहेरिट करने की आवश्यकता होती है, वह आइएसए को लिखा जाता है। मान लीजिए कि आपकी वस्तु NSArray या UITableView या CFDictionaryRef या किसी अन्य वस्तु की वंशज है। इस मामले में, "isa" एक NSArray या UITableView या CF retardRef या किसी अन्य ऑब्जेक्ट के लिए क्रमशः इंगित करता है। तो किसी भी वस्तु का एक उदाहरण बनाने से एक वर्ग चर भी बनता है - "इसा", जो सीधे मूल वर्ग को संदर्भित करता है, जिसके परिणामस्वरूप "रनटाइम" जानता है कि यह प्रत्येक उदाहरण के साथ क्या करेगा।
प्रशिक्षण के चरण में यह जानकारी कुछ विशिष्ट के लिए आवश्यक नहीं है, लेकिन, सिद्धांत रूप में, उद्देश्य-सी प्रोग्रामिंग दर्शन की अधिक व्यापक समझ के लिए।
किताबें पढ़ने और विभिन्न दस्तावेजों की प्रक्रिया में, "सिंगलटन" की अवधारणा एक से अधिक बार आई है। जैसा कि एक लोकप्रिय इंटरनेट मेमे कहता है: "आप तुरंत समझ नहीं सकते हैं और समझ सकते हैं कि एक सिंगलटन क्या है।

सिंगलटन क्या है?

कल्पना करें कि आपको एक ऑब्जेक्ट बनाने की आवश्यकता है, जो हर बार आवेदन के किसी भी बिंदु पर कॉल किया जाता है, वही उदाहरण देता है। वास्तव में, एप्लिकेशन बनाने की प्रक्रिया में, आपको वास्तव में एक बनाने की आवश्यकता होती है। तो आप कई बार एक ऑब्जेक्ट क्यों नहीं बना सकते हैं और "initWithSomething:" विधि या सेटर्स का उपयोग करके उसी डेटा को असाइन कर सकते हैं? यह सब स्मृति और गति के साथ काम करने के बारे में है, और वास्तव में, कम समय खर्च करने वाले लेखन कोड के साथ। हमेशा छोटी मेमोरी होती है, और यहां तक ​​कि जब वे iPhone6 ​​पर 2GB रैम लगाते हैं, तो यह फिर से छोटा हो जाएगा। ऑब्जेक्ट का एक उदाहरण बनाना, और फिर इसे एक्सेस करना, डिवाइस संसाधनों को बचाता है और एप्लिकेशन को गति देता है। लेकिन हर कोई चाहता है कि उसका आवेदन "बुगाटी वेरॉन" जितना तेज हो और "हॉर्सरैडिश" शब्द के रूप में प्रयोग करने योग्य हो।
मान लीजिए कि हमारा "प्राइमस" एक सिंगलटन हो सकता है। फिर उसकी विधि

 +(Primus *) hotAsHell; 

कार्यान्वयन के दौरान यह इस तरह दिखेगा

 +(Primus*) hotAsHell{ static Primus *myPrimus = nil; static dispatch_once_t predicate; dispatch_once (&predicate, ^{myPrimus = [[super alloc] init];}); return myPrimus; } 

बाद में इसका क्या मतलब है इस पर विचार करें। आइए जानें कि प्राइमस एक सिंगलटन क्यों है।
मान लीजिए कि यह सामान्य रूप से "प्राइमस" नहीं है, लेकिन दुर्लभ है। इसमें एक अज्ञात मास्टर द्वारा उत्कीर्णन है, इसमें गैस की खपत बहुत कम है, और इसके पास एक विशेष बॉक्स भी है जिसमें यह पूरी तरह से फिट बैठता है। अब अपने आप से सवाल पूछें: "क्या आपको एक और प्राइमस की जरूरत है?" बिल्कुल नहीं! लेकिन विधि भेजते समय

 Primus *myPrimus = [[Primus alloc] initWitGas:metan temperature:500]; 

एक "प्राइमस" बनाया जाएगा, और विधि भेजते समय

 Primus *myPrimus = [[Primus alloc] initWitGas:propan temperature:600]; 

एक पूरी तरह से अलग completely प्राइमस ”बनाया जाएगा। उत्कीर्णन और बक्से के बिना।
अब वापस "hotAsHell" पद्धति के कार्यान्वयन में जो लिखा गया है।
पहले आपको ऑब्जेक्ट को "स्थिर" संपत्ति के साथ बनाने की आवश्यकता है ताकि बाहर से ऑब्जेक्ट तक पहुंच को अवरुद्ध किया जा सके। फिर उसे "शून्य" असाइन करें ताकि वह स्मृति में एक यादृच्छिक पता न ले। डिज़ाइन

 static dispatch_once_t predicate; 

एक विधेय (स्थिति) बनाता है - "विधेय" जो बाहर से भी दिखाई नहीं देगा। शर्त यह है कि विधेय के पीछे ब्लॉक की स्वचालित या गतिशील कॉल निषिद्ध है। और यहां लाइन है।

 dispatch_once (&predicate, ^{myPrimus = [[super alloc] init];}); 

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

 ^{myPrimus = [[super alloc] init];} 

यह एक छोटे से कार्य या विधि की तरह है। बड़े ब्लॉक भी हैं। इस ब्लॉक में, पेरेंट ऑब्जेक्ट को इनिशियलाइज़ किया जाता है, जिसके बाद इसका मान myPrimus के वंशज को सौंपा जाता है।
साथ में पूरी लाइन

 dispatch_once (&predicate, ^{myPrimus = [[super alloc] init];}); 

का अर्थ है: एक बार आवेदन के पूरे जीवन चक्र के दौरान, मूल वस्तु के गुणों के साथ "myPrimus" नामक प्राइमस ऑब्जेक्ट का एक उदाहरण इनिशियलाइज़ किया जाएगा और इस ब्लॉक को दूसरे तरीके से एक्सेस करना संभव नहीं होगा। लेकिन किसी को नहीं पता कि "myPrimus" बनाया गया था, क्योंकि ऑब्जेक्ट का यह उदाहरण बाहर से दिखाई नहीं देता है। सब कुछ पृष्ठभूमि में होता है और केवल एक बार होता है। और यह जीसीडी (ग्रैंड सेंट्रल डिस्पैच) के लिए धन्यवाद होता है। जिसके बारे में कहानी एक अलग विषय है।
और निश्चित रूप से अंत में हम निर्मित सिंगलटन को वापस करते हैं

 return myPrimus; 

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

 Primus *myPrimus = [Primus hotAsHell]; 

और फिर "myPrimus" के साथ एक सिंगलटन के रूप में काम करना, फिर कुछ भी काम नहीं करेगा। सिंगलटन चर के लिए सभी कॉल निम्न तरीके से होने चाहिए।

 Box *someBox = [Primus hotAsHell].Box; 

इसलिए आप पूरी तरह से अलग बॉक्स के "someBox" का एक उदाहरण बना सकते हैं और उस मूल्य को असाइन कर सकते हैं जो हमारे सिंगलटन के बॉक्स में है, या इसके विपरीत।

 [Primus hotAsHell].Box = someBox; 

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

 [myPrimus doSomethingWith:Potato]; 

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

प्रोटोकॉल

प्रोटोकॉल के तरीके भी हैं। जैसा कि मैंने लेख की शुरुआत में संकेत दिया था, उनके वंशज नहीं हो सकते। वे सिर्फ तरीकों का एक संग्रह हैं। अपने भीतर प्रोटोकॉल पद्धति को लागू करने के लिए, वस्तु को इस प्रोटोकॉल का पालन करना चाहिए। यह * .h फ़ाइल में इंगित किया गया है

 @interface Primus : UIViewController <UITableViewDataSource, UITableViewDelegate> 

इस स्थिति में, ऑब्जेक्ट एक बार में दो प्रोटोकॉल "UITableViewDataSource" और "UITableViewDelegate" से मेल खाता है।

?

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

 -(UIColor *) areaDidChangeColor:(CGRect)rect isActive:(BOOL)active; 

जब स्वचालित रूप से निष्पादित किया जाता है जब तर्क "सक्रिय" मूल्य "YES" लेता है। और यह "रेक्ट" में वर्णित स्क्रीन के हिस्से में रंग बदलता है:

 { if (isActive && myForm == rect){ myColor = [UIColor redColor]; } return myColor; } 

प्रोटोकॉल विधियाँ वर्ग के उदाहरण के संचालन मापदंडों को निर्दिष्ट करती हैं, कार्यक्षमता को बदलती हैं, मानों को पास करती हैं। उदाहरण के लिए:

 -(NSInteger) tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section; 

दी गई तालिका के लिए "अनुभाग" अनुभाग में पंक्तियों की संख्या लौटाता है।

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