इंस्टेंस मेथड

क्लास Jar लिखें जिसमें int फ़ील्ड fill हो, कंस्ट्रक्टर Jar(int n) जो fill = n; रखे, और इंस्टेंस मेथड void bump() जो fill = fill + 1; चलाए। Pine में Main रखें और Jar j = new Jar(3); से एक jar बनाएँ, j.bump(); बुलाएँ, फिर j.fill लिखें। दोनों टाइप उसी शिक्षण फ़ाइल में रखें ताकि dotnet run सरल रहे। dotnet run से चलाएँ। स्क्रीन पर एक पंक्ति दिखनी चाहिए: 4। मेथड उसी एक ऑब्जेक्ट पर चलता है और उसका फ़ील्ड बदलता है। ऑब्जेक्ट वेरिएबल के ज़रिए मेथड बुलाना — यही इस पेज का पाठ है। शुरू करने वाली पब्लिक क्लास का नाम Pine रखें।

मेथड जो ऑब्जेक्ट का है

पहले के मेथड पेजों पर आप Main से नाम बुलाते थे बिना आगे ऑब्जेक्ट के। यहाँ मेथड क्लास पर बैठता है, लेकिन आप jar वेरिएबल से पहुँचते हैं: j.bump()। वह कॉल उसी jar के फ़ील्ड इस्तेमाल करता है जिसे j नाम देता है। दूसरा jar अपना fill रखेगा।
Pine फ़ाइल खोलें। शुरू करने वाली क्लास का नाम Pine ही रहता है। यह पेज स्टार्टर का नाम नहीं बदलता। अगर अभी भी Tin t = new Tin(7); बचा है और वही Main में सब कुछ है, उसे हटा दें। कोई भी बची Tin क्लास हटा दें। कोई भी ReadLine पंक्ति हटा दें। जो फ़ाइल आप रखते हैं वह टाइपिंग का इंतज़ार नहीं करती।
Pine के ब्रेसेस के बाहर — फिर भी उसी फ़ाइल में — लिखें public class Jar। ब्रेसेस के अंदर घोषित करें int fill;। कंस्ट्रक्टर लिखें Jar(int n) { fill = n; } अलग नामों के साथ ताकि इस पेज को this न चाहिए। फिर इंस्टेंस मेथड लिखें: void bump() { fill = fill + 1; }। इस पेज पर Jar में कोई Main नहीं है। चलाने से पहले फ़ाइल सेव करें।
मेथड हेडर को void चाहिए क्योंकि bump लिखने के लिए कोई मान नहीं लौटाता। कंस्ट्रक्टर पर अभी भी void नहीं — वह अंतर साफ़ रखें।

Pine एक jar बनाता है और bump बुलाता है

Pine में public static void Main() रहता है। Main के अंदर तीन पंक्तियाँ क्रम से लिखें: Jar j = new Jar(3);, फिर j.bump();, फिर Console.WriteLine(j.fill);। कंस्ट्रक्टर 3 संग्रहीत करता है। कॉल j.bump() एक जोड़ता है। लेखन नया मान दिखाता है। इस पेज पर आप Tin t = new Tin(7); नहीं लिखते। वह this पाठ था।

रखी हुई फ़ाइल ऊपर से पढ़ें। using System; छोटे नाम तैयार करता है। public class Pine स्टार्टर है। public static void Main() वह जगह है जहाँ रनटाइम शुरू होता है। व्यंजक new Jar(3) एक jar बनाता है और fill में 3 रखता है। कॉल j.bump() उसी ऑब्जेक्ट पर bump में प्रवेश करता है। बॉडी लिखती है fill = fill + 1, इसलिए fill बन जाता है 4। फिर Main लिखता है j.fill और स्क्रीन 4 दिखाती है।
dotnet run से चलाएँ। प्रोग्राम एक पंक्ति लिखता है और रुक जाता है। वह आपके टाइप करने का इंतज़ार नहीं करता। अगर dotnet run इंतज़ार करे, तो ReadLine अभी फ़ाइल में है। उस पंक्ति को हटाएँ और Pine में new Jar(3), j.bump(), और लेखन रखें, Jar में bump के साथ। स्क्रीन 4 दिखाती है। अगर स्क्रीन 7 दिखाए, तो बचा Tin डेमो अभी चल रहा है। अगर स्क्रीन 3 दिखाए, तो bump कॉल गायब हो सकती है या लेखन के बाद चल रही हो।
अगर बिना आगे j. के लिखें bump();, तो इस आकार के Main में बिल्ड मना करता है। इंस्टेंस मेथड को ऑब्जेक्ट चाहिए। अगर static कॉल की तरह लिखें Jar.bump();, वह अगले पाठ का विचार है — इस पेज का नहीं। रखें j.bump();।

this और सादे फ़ील्ड असाइन से तुलना

this पेज पर आप कंस्ट्रक्टर के अंदर मिलते नामों से फ़ील्ड संग्रहीत करते थे। वह अभी भी काम करता है। यह पेज एक मेथड जोड़ता है जिसे आप बाद में बुला सकते हैं, जब ऑब्जेक्ट पहले से मौजूद हो। बचा Tin t = new Tin(7); जिसमें this.size = size; हो, अलग पाठ है। इस पेज के लिए Jar और Pine और j.bump(); रखें।
आप अभी भी Main में j.fill = j.fill + 1; लिख सकते थे। यह पाठ उस बदलाव को bump के अंदर ले जाता है ताकि ऑब्जेक्ट क्रिया ले जाए। केवल Console.WriteLine(j); लिखना साफ़ 4 नहीं दिखाता। संग्रहीत संख्या देखने के लिए Console.WriteLine(j.fill); लिखें।

एक jar पर दो bump

आप लिखने से पहले दो बार j.bump(); बुला सकते हैं। new Jar(3) से शुरू करें, एक bump से 4, दूसरा bump से 5, फिर लिखें। वह जाँच एक छोटी दूसरी pine डेमो में समा जाती है।

फिर dotnet run से चलाएँ। स्क्रीन को 5 दिखाना चाहिए। हर bump कॉल उसी ऑब्जेक्ट पर चली और एक और जोड़ा। Jar k = j; लिखना दूसरा ऑब्जेक्ट नहीं बनाता — जब दो अलग fill चाहें तो दो new Jar(...) कॉल करें। इस पेज के लिए एक jar पर दो bump काफी हैं ताकि मेथड दो बार चलता दिखे।
अगर स्क्रीन अभी भी 3 दिखाए, तो bump कॉल गायब हो सकती हैं या Main अभी भी बुलाने से पहले लिख रहा हो। अगर 7 या कोई और बचा नंबर दिखे, तो पुराना Tin डेमो अभी फ़ाइल में हो सकता है। रखें new Jar(3) और bump कॉल।

यह पेज static के लिए क्या छोड़ता है

यह पेज मेथड को ऑब्जेक्ट के ज़रिए बुलाता है: j.bump()। बाद का पेज — static — ऐसे मेथड और फ़ील्ड दिखाता है जो खुद क्लास नाम के हैं बिना आगे ऑब्जेक्ट के। यहाँ इंस्टेंस कॉल पर रहें। इस पेज पर static void bump() न गढ़ें जब तक आप पहले से न जानते हों; पाठ का लक्ष्य ऑब्जेक्ट पर कॉल है।
Jar को Pine के ब्रेसेस के अंदर नेस्ट न करें। इस पेज पर दोनों क्लास फ़ाइल में सहोदर की तरह बैठती हैं। अगर बिल्ड Pine कंपाइल करते समय Jar नहीं ढूँढ पाए, जाँचें कि public class Jar उसी फ़ाइल में है। अगर स्क्रीन 0 दिखाए, तो कंस्ट्रक्टर में संग्रह न हो या bump कभी न चले — रखें Jar(int n) { fill = n; } और लेखन से पहले j.bump();।

आप घोषित कर सकते हैं int fill;, लिख सकते हैं Jar(int n) { fill = n; } और void bump() { fill = fill + 1; }, और Pine.Main से चला सकते हैं Jar j = new Jar(3);, j.bump();, फिर लिखें j.fill। dotnet run से चलाएँ। स्क्रीन 4 दिखाती है। इंस्टेंस मेथड उस ऑब्जेक्ट पर चला और उसका फ़ील्ड बदला। bump को उस क्रिया की तरह देखें जो jar मौजूद होने के बाद कर सकता है। Pine वही दरवाज़ा है जिसे आप dotnet run से खोलते हैं। अगला पेज static है, जहाँ कुछ सदस्य क्लास नाम के हैं बिना आगे ऑब्जेक्ट वेरिएबल के।
मेथड पर void रखें, कंस्ट्रक्टर पर नहीं। कॉल से पहले ऑब्जेक्ट रखें: j.bump();। लेखन j.fill पर रखें। ये तीन आदतें आगे बढ़ने से पहले इस पेज की जाँच-बिंदु हैं।