ओवरलोडिंग
एक कक्षा में दो मेथड रखें जो दोनों नाम paint का उपयोग करें. एक हेडर static void paint(string word) है. दूसरा static void paint(int n) है. बॉडी छोटी हैं: पहली word लिखती है, दूसरी n लिखती है. Main से कॉल करें paint("ok"); और फिर paint(3);. स्क्रीन को दो पंक्तियाँ दिखानी चाहिए: पहली पर ok और दूसरी पर 3. C# दूसरे paint को टकराव नहीं मानता. वह दोनों हेडर को अलग मेथड मानता है क्योंकि पैरामीटर सूचियाँ भिन्न हैं. अलग सूचियों के साथ यही साझा नाम वह है जो यह पृष्ठ सिखाता है. सार्वजनिक कक्षा का नाम Pine रखें.
एक नाम, अलग सूचियाँ
अब तक हर नया विचार नया मेथड नाम लेता था: ring, greet, twice. यहाँ जानबूझकर नाम paint रहता है. जो बदलता है वह कोष्ठकों के बीच है. एक सूची में string है. दूसरी सूची में int है. कंपाइलर दोनों रखता है क्योंकि वे सूचियाँ एक जैसी नहीं हैं.
Pine फाइल खोलें. कक्षा का नाम Pine रहता है. यह पृष्ठ प्रकार का नाम नहीं बदलता. अगर अभी भी twice डेमो है जो n * 2 लौटाता है और Main में बस वही है, तो उसे हटाएँ. कोई भी बचा greet हटाएँ. कोई भी ReadLine पंक्ति हटाएँ. जो फाइल आप रखते हैं उसमें टाइप की प्रतीक्षा नहीं है.
Main के बाहर, फिर भी कक्षा की ब्रेसेस के अंदर, दोनों paint हेडर लिखें. इस पृष्ठ पर void रखें: हर बॉडी लिखती है, और return से Main को कुछ लौटाने की ज़रूरत नहीं. पहली बॉडी Console.WriteLine(word); उपयोग करती है. दूसरी Console.WriteLine(n); उपयोग करती है. चलाने से पहले फाइल सहेजें. पूरा पहला प्रोग्राम अगले बॉक्स में है.
जो फाइल आप रखते हैं
यह वह संस्करण है जिसे आप पहले चलाते हैं. Main दो कॉल रखता है. कक्षा दो paint मेथड रखती है जो एक नाम साझा करते हैं.
using System;
public class Pine
{
public static void Main()
{
paint("ok");
paint(3);
}
static void paint(string word)
{
Console.WriteLine(word);
}
static void paint(int n)
{
Console.WriteLine(n);
}
}
ऊपर से पढ़ें. using System; छोटे नाम तैयार करता है. public class Pine प्रकार का नाम रखता है. public static void Main() वह जगह है जहाँ रनटाइम शुरू होता है. पहली कॉल paint("ok") है. आर्ग्युमेंट एक string है, इसलिए C# वह बॉडी चलाता है जो string word लेती है और ok लिखती है. दूसरी कॉल paint(3) है. आर्ग्युमेंट एक int है, इसलिए C# वह बॉडी चलाता है जो int n लेती है और 3 लिखती है. नाम paint दोनों बार एक जैसा है. कोष्ठकों के अंदर की सूची ही बॉडी चुनती है. स्क्रीन पर दो पंक्तियाँ: ok, फिर 3.
dotnet run से चलाएँ. प्रोग्राम दो पंक्तियाँ लिखता है और रुक जाता है. वह आपके टाइप करने की प्रतीक्षा नहीं करता. अगर dotnet run प्रतीक्षा करे, तो फाइल में अभी भी ReadLine है. वह पंक्ति हटाएँ और ऊपर दी दोनों paint कॉल तथा दोनों paint मेथड रखें. स्क्रीन ok, फिर 3 दिखाती है. अगर दोनों पंक्तियाँ ok दिखाएँ, तो शायद केवल string मेथड बचा और हर कॉल के लिए एक स्थिर शब्द लिखा. अगर दोनों पंक्तियाँ 3 दिखाएँ, तो शायद केवल int मेथड बचा. दोनों हेडर रखें. अगर बिल्ड कहे कि paint पहले से परिभाषित है, जाँचें कि दोनों हेडर की सूची एक जैसी तो नहीं — उदाहरण के लिए paint(string word) की दो प्रतियाँ. ओवरलोडिंग को सूची में वास्तविक अंतर चाहिए, केवल अलग पैरामीटर नाम वाली वही हेडर की दूसरी प्रति नहीं. गलत पंक्तियाँ दिखाने वाली स्क्रीन के लिए आप .NET SDK दोबारा इंस्टॉल नहीं करते.
दो शब्दों वाली दूसरी सूची
पैरामीटर की गिनती भी भिन्न हो सकती है. तीसरा ओवरलोड जोड़ें जो दो string मान ले और उन्हें एक पंक्ति पर स्पेस के साथ लिखे. जब आप तीनों को साथ अभ्यास करें तो पहले दो paint मेथड वहीं छोड़ें. केवल इसी आकार के केंद्रित डेमो के लिए आप ऐसी फाइल रख सकते हैं जिसमें केवल यही सूची हो.
using System;
public class Pine
{
public static void Main()
{
paint("hi", "sam");
}
static void paint(string a, string b)
{
Console.WriteLine(a + " " + b);
}
}
यह दूसरी फाइल है. यह गिनती को सूची का अंतर सिखाती है. dotnet run चलाएँ. स्क्रीन को एक पंक्ति दिखानी चाहिए: hi sam. कॉल में दो आर्ग्युमेंट हैं. मेथड में दो पैरामीटर हैं. यही मेल C# के लिए इस बॉडी को चुनने के लिए काफी है. अगर अभी भी पहले वाले paint(string word) और paint(int n) उसी कक्षा में हैं, आप उन्हें रख सकते हैं. दो string मान वाली कॉल एक-आर्ग्युमेंट string मेथड नहीं चुनेगी, क्योंकि गिनती भिन्न है.
जब अभ्यास के लिए तीनों ओवरलोड एक फाइल में रखें, Main हर आकार को अपनी पंक्ति पर कॉल कर सकता है. एक string वाली कॉल अभी भी paint(string word) पर जाती है. एक int वाली कॉल अभी भी paint(int n) पर जाती है. दो string मान वाली कॉल paint(string a, string b) पर जाती है. साझा नाम उन अंतरों को मिटाता नहीं. hi sam देखने के बाद, अगर वह आकार है जो आप रखना चाहते हैं, तो दो-कॉल वाली रखी फाइल वापस लाएँ: paint("ok"); फिर paint(3);.
string सूची के पास खाली सूची
खाली कोष्ठकों वाला मेथड भी एक अलग सूची है. आप बिना पैरामीटर वाले paint() को paint(string word) के पास रख सकते हैं. खाली कॉल paint(); खाली-सूची बॉडी चलाती है. कॉल paint("go"); string बॉडी चलाती है.
using System;
public class Pine
{
public static void Main()
{
paint();
paint("go");
}
static void paint()
{
Console.WriteLine("ready");
}
static void paint(string word)
{
Console.WriteLine(word);
}
}
यह तीसरी फाइल है. dotnet run चलाएँ. स्क्रीन को पहली पंक्ति पर ready और दूसरी पर go दिखाना चाहिए. पहली कॉल में कोष्ठकों के बीच कुछ नहीं है, इसलिए वह paint() से मेल खाती है. दूसरी कॉल एक string भेजती है, इसलिए वह paint(string word) से मेल खाती है. एक मेथड का नाम paintReady करने पर भी बिल्ड होगा, लेकिन वह अलग कौशल है. यह पृष्ठ नाम paint रखता है और सूचियों को अंतर उठाने देता है.
कौन-सी कॉल कौन-सा हेडर चलाती है
कॉल को हेडर के पास पढ़ें. कॉल में आर्ग्युमेंट सूची हेडर में पैरामीटर सूची से मेल खानी चाहिए. इस शुरुआती आकार पर प्रकार और गिनती दोनों मायने रखते हैं.
📊 call beside matching paint
| Call in Main | Header that runs | Screen line |
|---|---|---|
paint("ok"); |
paint(string word) |
ok |
paint(3); |
paint(int n) |
3 |
paint("hi", "sam"); |
paint(string a, string b) |
hi sam |
paint(); |
paint() |
ready |
एक आम उलझन यह है कि दोनों मेथड paint(string word) लिखें और उम्मीद करें कि दूसरा ओवरलोड गिना जाए. केवल पैरामीटर नाम बदलकर paint(string label) करना कंपाइलर के लिए नई सूची नहीं बनाता. यहाँ प्रकार और गिनती मायने रखते हैं. दूसरी उलझन paint(true) कॉल करना है जब आपने कभी bool पैरामीटर सूची नहीं लिखी. तब बिल्ड मिलता हुआ paint नहीं ढूँढ पाता. वह हेडर जोड़ें जो आपका वांछित प्रकार ले, या कॉल को उस प्रकार में बदलें जिसका समर्थन आप पहले से करते हैं.
Main में Console.WriteLine("paint"); लिखना शब्द paint लिखता है. यह कोई मेथड नहीं बुलाता. जब आप वह ओवरलोड चाहते हैं जो string लेता है तो paint("ok"); रखें. उसी फाइल में बचा twice मेथड स्क्रीन को भ्रमित कर सकता है अगर Main अभी भी twice(7) लिखता है. Main को उन paint कॉल तक साफ़ करें जिनका आप परीक्षण कर रहे हैं, और उस रन के लिए केवल ज़रूरी paint ओवरलोड रखें.
Main की ब्रेसेस के अंदर paint मेथड नेस्ट न करें. मेथड कक्षा के अंदर, Main के पास बैठते हैं. दो ओवरलोड उसी कक्षा बॉडी में दो सहोदर मेथड हैं.
आप एक ही कक्षा में एक मेथड नाम और कई पैरामीटर सूचियाँ रख सकते हैं. C# कॉल की आर्ग्युमेंट सूची से बॉडी चुनता है. स्क्रीन मिलती बॉडी की पंक्ति दिखाती है. एक जैसी सूची वाले दो हेडर ओवरलोड नहीं हैं. अगला पृष्ठ scope है, जहाँ आप देखते हैं कौन-से नाम मेथड के अंदर दिखते हैं और कौन-से बाहर रहते हैं.
स्क्रीन मिलती बॉडी रखती है
जो फाइल आप रखते हैं वह ok, फिर 3 लिखती है जब Main paint("ok"); और paint(3); कॉल करता है. साझा नाम paint हर कॉल में है, और अक्षर paint स्क्रीन पर मुद्रित लेबल नहीं हैं जब तक आपने उन्हें उद्धरण में न रखा हो. Main के अंदर paint मेथड नेस्ट करना इस पाठ का आकार नहीं है.
🧠 अपने ज्ञान की परीक्षा करें
अपने ज्ञान की परीक्षा करें
इस इंटरैक्टिव क्विज़ के साथ अपनी चुनौती लें और देखें कि आप विषय को कितनी अच्छी तरह समझते हैं
📝 निर्देश
- हर प्रश्न को ध्यान से पढ़ें
- हर प्रश्न के लिए सबसे अच्छा उत्तर चुनें
- आप जितनी बार चाहें क्विज़ दोबारा दे सकते हैं
- आपकी प्रगति शीर्ष पर दिखाई जाएगी