ऑब्जेक्ट
Chip नाम की क्लास लिखें जिसमें मेथड beep हो जो ok लिखे। इस पेज पर मेथड static नहीं है। Pine में Main रखें और Chip c = new Chip(); से एक chip बनाएँ, फिर c.beep(); बुलाएँ। दोनों टाइप उसी शिक्षण फ़ाइल में रखें ताकि dotnet run सरल रहे। dotnet run से चलाएँ। स्क्रीन पर एक पंक्ति दिखनी चाहिए: ok। शब्द new क्लास से एक ऑब्जेक्ट बनाता है। चर c उसी ऑब्जेक्ट को रखता है। आप beep को c पर बुलाते हैं, खाली क्लास नाम पर नहीं। यही बना हुआ ऑब्जेक्ट — और वह कॉल जो उसे इस्तेमाल करती है — इस पेज का पाठ है। शुरू करने वाली पब्लिक क्लास का नाम Pine रखें।
क्लास से एक ऑब्जेक्ट
क्लास अभी भी नाम वाला टाइप है। ऑब्जेक्ट उस टाइप से बनी एक वैल्यू है। पंक्ति new Chip() C# से वह वैल्यू बनाने को कहती है। आप उसे ऐसे चर में रखते हैं जिसका टाइप Chip है, फिर उसी चर से उन मेथड तक पहुँचते हैं जो हर ऑब्जेक्ट की हैं।
Pine फ़ाइल खोलें। शुरू करने वाली क्लास का नाम Pine ही रहता है। यह पेज स्टार्टर का नाम नहीं बदलता। अगर अभी भी Badge.show(); बचा है और वही Main में सब कुछ है, उसे हटा दें। कोई भी बचा down रिकर्शन हटा दें। कोई भी ReadLine पंक्ति हटा दें। जो फ़ाइल आप रखते हैं वह टाइपिंग का इंतज़ार नहीं करती।
Pine के ब्रेसेस के बाहर — फिर भी उसी फ़ाइल में — लिखें public class Chip। Chip के अंदर लिखें void beep() — इस हेडर पर static शब्द न हो। बॉडी एक लिखने की पंक्ति है: Console.WriteLine("ok");। void रखें। मेथड कोई नंबर वापस नहीं करती। इस पेज पर Chip में कोई Main नहीं है। चलाने से पहले फ़ाइल सेव करें।
पहला बॉक्स वाला प्रोग्राम अकेला Chip दिखाता है ताकि आप टाइप साफ़ पढ़ सकें। बाद के बॉक्स वाले प्रोग्राम रखे हुए आकार हैं जहाँ Pine एक chip, फिर दो बनाता है।
using System;
public class Chip
{
void beep()
{
Console.WriteLine("ok");
}
}
Pine chip बनाता है, फिर beep बुलाता है
Pine में public static void Main() रहता है। Main के अंदर दो पंक्तियाँ लिखें: पहले Chip c = new Chip();, फिर c.beep();। पहली पंक्ति टाइप Chip का चर c घोषित करती है और उसे नए ऑब्जेक्ट से भरती है। दूसरी पंक्ति उसी ऑब्जेक्ट पर beep बुलाती है। डॉट चर नाम के बाद आता है, अकेले क्लास नाम के बाद नहीं। इस पेज पर आप Badge.show(); नहीं लिखते। वह क्लास पाठ की static कॉल थी।
using System;
public class Pine
{
public static void Main()
{
Chip c = new Chip();
c.beep();
}
}
public class Chip
{
void beep()
{
Console.WriteLine("ok");
}
}
रखी हुई फ़ाइल ऊपर से पढ़ें। using System; छोटे नाम तैयार करता है। public class Pine स्टार्टर है। public static void Main() वह जगह है जहाँ रनटाइम शुरू होता है। व्यंजक new Chip() एक ऑब्जेक्ट बनाता है। वह ऑब्जेक्ट c में संग्रहीत होता है। कॉल c.beep() उसी ऑब्जेक्ट के लिए beep में जाती है। मेथड ok लिखती है और लौटती है। फिर Pine खत्म होता है। स्क्रीन पर शब्द ऑब्जेक्ट की मेथड से आया, जब new ने ऑब्जेक्ट बनाया।
dotnet run से चलाएँ। प्रोग्राम एक पंक्ति लिखता है और रुक जाता है। वह आपके टाइप करने का इंतज़ार नहीं करता। अगर dotnet run इंतज़ार करे, तो ReadLine अभी फ़ाइल में है। उस पंक्ति को हटाएँ और Pine में Chip c = new Chip(); के साथ c.beep(); रखें, और Chip में beep। स्क्रीन ok दिखाती है। अगर स्क्रीन ready दिखाए, तो बचा Badge.show(); कॉल अभी चल रहा है। अगर स्क्रीन अक्षर Chip दिखाए, तो लिखने की पंक्ति में कोट्स हैं: Console.WriteLine("Chip");। गलत पंक्ति दिखने पर आप .NET SDK दोबारा इंस्टॉल नहीं करते।
एक बार फिर रन क्रम से चलें। C# Pine.Main से शुरू होता है। पहला स्टेटमेंट new Chip() से एक ऑब्जेक्ट बनाता है और उसे c में रखता है। दूसरा स्टेटमेंट c.beep() बुलाता है। beep के अंदर WriteLine ok लिखता है। फिर beep खत्म होती है, और Main में कुछ नहीं बचा, इसलिए प्रोग्राम खत्म। आपने इस पेज पर Console.WriteLine("ok"); Pine के अंदर नहीं रखा। आपने उसे Chip के नीचे रखा और ऑब्जेक्ट चर से माँगा।
क्लास को फ़ाइल में ब्लूप्रिंट समझें और ऑब्जेक्ट को इस रन के लिए मेमोरी में बनी एक पीस। हर new Chip() दूसरी पीस बनाता है। चर उस पीस का नाम रखता है ताकि बाद की पंक्तियाँ पहुँच सकें। बिना उस नाम के, बनी पीस के पास इस पेज पर beep के लिए हैंडल नहीं है।
कॉल c से क्यों, अकेले Chip से नहीं
क्लास पेज पर static मेथड को Badge.show() से टाइप नाम के साथ बुलाया जा सकता था। यहाँ beep में static शब्द नहीं है। C# पहले एक ऑब्जेक्ट चाहता है। बिना ऑब्जेक्ट Chip.beep(); लिखना इस शुरुआती आकार से मेल नहीं खाता। new से बनाएँ, नतीजा चर में रखें, फिर उसी चर से बुलाएँ।
अगर आप केवल new Chip(); लिखें और कभी संग्रहीत न करें, तो आपने फिर भी ऑब्जेक्ट बनाया, लेकिन beep बुलाने के लिए कोई नाम नहीं बचा। इस पेज पर चर रखें: Chip c = new Chip(); फिर c.beep();। चर वह तरीका है जिससे new खत्म होने के बाद ऑब्जेक्ट तक पहुँचते हैं।
बचा static डेमो Main को उलझा सकता है। जो फ़ाइल अभी भी Badge.show(); बुलाती है वह पिछले पाठ का आकार है। इस पेज के लिए Chip और Pine और new पंक्ति रखें। यहाँ Badge की ज़रूरत नहीं।
दो ऑब्जेक्ट, दो beep
आप उसी क्लास से एक से अधिक ऑब्जेक्ट बना सकते हैं। हर new Chip() अलग ऑब्जेक्ट बनाता है। हर ऑब्जेक्ट अपना beep चला सकता है। क्लास का पाठ साझा है; ऑब्जेक्ट एक ही वैल्यू नहीं हैं।
using System;
public class Pine
{
public static void Main()
{
Chip a = new Chip();
Chip b = new Chip();
a.beep();
b.beep();
}
}
public class Chip
{
void beep()
{
Console.WriteLine("ok");
}
}
फिर dotnet run से चलाएँ। स्क्रीन पर दो पंक्तियाँ दिखनी चाहिए: ok, फिर ok। पहली पंक्ति a से आई। दूसरी b से। दोनों ने Chip में उसी beep मेथड पाठ का उपयोग किया, लेकिन हर कॉल अलग ऑब्जेक्ट पर चली जो new से बना।
अगर स्क्रीन केवल एक ok दिखाए, जाँचें कि दोनों कॉल मौजूद हैं और दोनों चर new से बने। लिखना Chip b = a; दूसरा ऑब्जेक्ट नहीं बनाता; यह b को उसी ऑब्जेक्ट की ओर इंगित करता है जिसकी ओर a है। वह विचार बाद के पेजों के लिए है। इस पेज पर जब दो ऑब्जेक्ट चाहें तो दो new Chip() व्यंजक लिखें।
अगर चाहें तो चर का नाम c से unit कर सकते हैं: Chip unit = new Chip(); फिर unit.beep();। जब मेथड बॉडी अभी भी वही शब्द लिखती है तो स्क्रीन ok रहती है। चर का नाम आपका है; टाइप नाम Chip और व्यंजक new Chip() अभी भी सहमत रहना चाहिए।
यह पेज फ़ील्ड के लिए क्या छोड़ता है
यह पेज अभी chip के अंदर कोई संख्या या शब्द संग्रहीत नहीं करता। फ़ील्ड — नाम जो हर ऑब्जेक्ट पर डेटा रखते हैं — अगला पेज हैं। यहाँ ऑब्जेक्ट new के बाद मौजूद है, और इंस्टेंस मेथड beep केवल लिखती है। टाइप के रूप में क्लास और बनी वैल्यू के रूप में एक ऑब्जेक्ट का विभाजन देखने के लिए यही काफी है।
Chip को Pine के ब्रेसेस के अंदर नेस्ट न करें। इस पेज पर दोनों क्लास फ़ाइल में समान स्तर पर बैठती हैं। Chip की मेथड Chip के अंदर हैं। Main Pine के अंदर है। आप beep के अंदर लिखा शब्द ping कर सकते हैं और फिर चलाएँ। स्क्रीन को उस स्ट्रिंग का पालन करना चाहिए जो आपने Chip में रखी। Pine का new और कॉल आकार वही रहता है।
अगर बिल्ड Pine कंपाइल करते समय Chip न ढूँढे, जाँचें कि public class Chip उसी फ़ाइल में है और क्लास पंक्ति सच में Chip कहती है। अगर रन कुछ न लिखे, पुष्टि करें कि Main अभी भी new पंक्ति के बाद c.beep(); बुलाता है, और beep में अभी भी WriteLine है।
आप Chip को void beep() के साथ लिख सकते हैं, Chip c = new Chip(); से एक ऑब्जेक्ट बना सकते हैं, और Pine.Main से c.beep(); बुला सकते हैं। dotnet run से चलाएँ। स्क्रीन ok दिखाती है। दूसरा new Chip() दूसरा ऑब्जेक्ट बनाता है जो खुद beep कर सकता है। Chip को ब्लूप्रिंट समझें और हर new Chip() को एक बनी पीस जिसे आप नाम दे सकते हैं। Pine वही दरवाज़ा है जो आप dotnet run से खोलते हैं। अगला पेज फ़ील्ड है, जहाँ हर ऑब्जेक्ट अपना संग्रहीत डेटा रखना शुरू करता है।
🧠 अपने ज्ञान की परीक्षा करें
अपने ज्ञान की परीक्षा करें
इस इंटरैक्टिव क्विज़ के साथ अपनी चुनौती लें और देखें कि आप विषय को कितनी अच्छी तरह समझते हैं
📝 निर्देश
- हर प्रश्न को ध्यान से पढ़ें
- हर प्रश्न के लिए सबसे अच्छा उत्तर चुनें
- आप जितनी बार चाहें क्विज़ दोबारा दे सकते हैं
- आपकी प्रगति शीर्ष पर दिखाई जाएगी