मेन्यू

OOPS कॉन्सेप्ट इन C #: ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग कॉन्सेप्ट ट्यूटोरियल

  • मुख्य
  • अन्य
  • OOPS कॉन्सेप्ट इन C #: ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग कॉन्सेप्ट ट्यूटोरियल

oops concepts c object oriented programming concept tutorial

समस्याओं को खत्म करने के लिए हमारे साधन का प्रयास करें

यह ट्यूटोरियल C # में OOPS अवधारणाओं को समझाता है। आप ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग प्रिंसिपल्स जैसे पॉलिमॉर्फिज्म, इनकैप्सुलेशन, इनहेरिटेंस और एब्सट्रैक्शन के बारे में जान सकते हैं:

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

वांछित परिणाम प्राप्त करने के लिए इन वस्तुओं पर काम करना ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग का लक्ष्य है।

=> यहाँ सी # प्रशिक्षण ट्यूटोरियल की पूरी श्रृंखला का अन्वेषण करें

OOPS अवधारणाओं को C # में

आइए हम अपने पहले के ट्यूटोरियल में सीखी गई कुछ अवधारणाओं को संशोधित करें !!

नाम स्थान

C # में एक नामस्थान कक्षाओं का एक संग्रह है। यह एक वर्ग के नाम को दूसरे नाम से अलग श्रेणी के नाम से अलग रखने के लिए एक संरचना प्रदान करता है। ताकि समान नाम वाले वर्ग एक दूसरे के साथ संघर्ष न करें।

कक्षा

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

वस्तुओं

वस्तुएं वर्ग के उदाहरण हैं।

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

आप क्या सीखेंगे:

OOPS अवधारणाओं में C #

ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग अन्य प्रोग्रामिंग मॉडल पर कई फायदे प्रदान करता है जैसे:

  1. कार्यक्रमों के लिए सटीक और स्पष्ट मॉड्यूलर दृष्टिकोण आसान समझ और रखरखाव प्रदान करता है।
  2. परियोजना में निर्मित कक्षाएं और वस्तुएं परियोजना के पार इस्तेमाल की जा सकती हैं।
  3. मॉड्यूलर दृष्टिकोण अलग-अलग मॉड्यूल को स्वतंत्र रूप से मौजूद करने की अनुमति देता है, जिससे कई अलग-अलग डेवलपर्स को अलग-अलग मॉड्यूल पर एक साथ काम करने की अनुमति मिलती है।

इस ट्यूटोरियल में, हम अन्य प्रमुख कोर OOPS अवधारणाओं पर अधिक ध्यान केंद्रित करेंगे:

  1. कैप्सूलीकरण
  2. बहुरूपता
  3. विरासत
  4. मतिहीनता

कैप्सूलीकरण

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

एक्सेस स्पेसियर्स का उपयोग करके एनकैप्सुलेशन लागू किया जाता है। एक्सेस विनिर्देशक का उपयोग C # में कक्षा सदस्य की दृश्यता और पहुंच को परिभाषित करने के लिए किया जाता है।

C # में निम्न पहुँच विनिर्देशक हैं।

एप्लिकेशन को इंस्टाग्राम पोस्ट को मुफ्त में शेड्यूल करें
  • जनता
  • निजी
  • संरक्षित
  • अंदर का

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

आइए उन पर एक नजर डालें।

जनता: सार्वजनिक कीवर्ड अपने सदस्यों को प्रोजेक्ट के अंदर कहीं से भी दिखाई दे सकता है। इस एक्सेस स्पेसियर में कम से कम दृश्यता प्रतिबंध है।

निजी: निजी सदस्यों को केवल उसी वर्ग के सदस्य द्वारा पहुँचा जा सकता है। यह सबसे प्रतिबंधित दृश्यता में से एक है।

संरक्षित: संरक्षित पहुंच सदस्य को वर्ग के भीतर और इस वर्ग से विरासत में मिली किसी अन्य कक्षा से एक्सेस करने की अनुमति देता है।

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

बहुरूपता

बहुरूपता ग्रीक शब्दकोष से लिया गया है, इसका अर्थ है कई रूपों वाला। पॉली कई के लिए खड़ा है और मॉर्फ का अर्थ है फॉर्म। यह सी # में वर्ग को एक ही नाम के साथ कई कार्यान्वयन करने की अनुमति देता है।

बहुरूपता मूल रूप से दो भागों में विभाजित है:

  1. संकलन-समय बहुरूपता
  2. भागो समय बहुरूपता

(1) स्टेटिक या कम्पाइल टाइम पॉलिमोर्फिज्म

संकलन-समय के बहुरूपता को स्थैतिक बहुरूपता के रूप में भी जाना जाता है। विधि ओवरलोडिंग उन तरीकों में से एक है जिसमें संकलन-समय के बहुरूपता को प्राप्त किया जाता है। इसे संकलन-समय के बहुरूपता के रूप में जाना जाता है क्योंकि विधि कॉलिंग निर्णय संकलन के समय किया जाता है।

यह विधि नाम को समान लेकिन मापदंडों के विभिन्न सेटों को पारित करके प्राप्त किया जाता है। ओवरलोडिंग विधि में, सिस्टम पहले उपयोग किए गए पैरामीटर की जांच करता है और पैरामीटर के सेट के आधार पर यह उपयुक्त विधि को कॉल करने का निर्णय लेता है।

उदाहरण:

class Program { void print(int i, int j) { Console.WriteLine('Printing int: {0}', (i+j) ); } void print(string a, string b) { Console.WriteLine('Printing String: ' , (a+b)); } static void Main(string() args) { Program prog = new Program(); // Call print for sum of integers prog.print(5, 6); // Call to concatenate strings prog.print('Hello','World'); Console.ReadKey(); } }

उपरोक्त उदाहरण में, हमने एक ही विधि को विभिन्न मापदंडों का उपयोग करके दो बार 'प्रिंट' कहा है। सबसे पहले, हम दो पूर्णांकों को पैरामीटर के रूप में पास करते हैं, फिर हमने दो स्ट्रिंग्स को पैरामीटर के रूप में पास किया है। एक ही नाम के साथ दो 'प्रिंट' विधियां हैं।

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

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

# 2) गतिशील बहुरूपता या रनटाइम बहुरूपता

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

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

उदाहरण:

class Program { public void print() { Console.WriteLine('Printing from class Program'); } } class Execute : Program { public void print() { Console.WriteLine('Printing from class Execute'); } public static void Main(string() args) { Execute exe = new Execute(); exe.print(); Console.ReadLine(); } }

यदि हम उपरोक्त कार्यक्रम चलाते हैं तो हमें निम्नलिखित आउटपुट प्राप्त होंगे:

Printing from class Execute

भले ही क्लास एक्सक्यूट को क्लास प्रोग्राम के सभी तरीके विरासत में मिले हों, लेकिन जब हम मेथड प्रिंट को बुलाते हैं, जो दोनों कक्षाओं में मौजूद होता है, तो चाइल्ड क्लास में मौजूद तरीका पेरेंट क्लास के तरीके को ओवरराइड कर देगा।

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

विरासत

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

पैरेंट क्लास को बेस क्लास के रूप में भी जाना जाता है और बेस क्लास इनहेरिट करने वाले चाइल्ड क्लास को व्युत्पन्न क्लास के रूप में भी जाना जाता है।

उदाहरण:

class Program { public void print() { Console.WriteLine('Printing from class Program'); } } class Execute : Program { public static void Main(string() args) { Execute exe = new Execute(); exe.print(); Console.ReadLine(); } }

यहां, हमारे पास एक प्रोग्राम के रूप में नामित एक वर्ग है जिसमें एक विधि है। हमारे पास एक और क्लास एक्सक्यूट है जो क्लास प्रोग्राम को विरासत में मिला है। क्लास एक्सिक्यूट व्युत्पन्न क्लास है और क्लास प्रोग्राम को बेस क्लास के रूप में जाना जाता है।

अब, क्लास प्रोग्राम के लिए ऑब्जेक्ट इंस्टेंस बनाने के बजाय, हमने क्लास एक्सेक्यूट के लिए ऑब्जेक्ट इंस्टेंस बनाया है। इस उदाहरण का उपयोग करके हम बेस क्लास से प्रिंट विधि का उपयोग कर सकते हैं।

तो, उपरोक्त कोड का उत्पादन होगा:

Printing from class Program

व्युत्पन्न वर्ग केवल विरासत के तरीके नहीं रखता है, यह दृश्यता के आधार पर लगभग सभी वर्ग सदस्यों जैसे क्षेत्र, गुण आदि को भी विरासत में प्राप्त करता है। C # में निहितता कई उत्तराधिकारियों के उपयोग की अनुमति नहीं देती है यानी एक वर्ग कई अलग-अलग वर्गों से विरासत में नहीं मिल सकता है, हालाँकि, एक वर्ग दूसरे वर्ग से विरासत में मिल सकता है जो एक अलग वर्ग से विरासत में मिल सकता है।

मतिहीनता

अमूर्त वस्तु-उन्मुख प्रोग्रामिंग के प्रमुख सिद्धांतों में से एक है। अमूर्तता प्रोग्रामर को दूसरों को छिपाते हुए दुनिया के लिए केवल आवश्यक विवरण प्रदर्शित करने की अनुमति देता है। अमूर्त वर्ग और इंटरफ़ेस का उपयोग करके C # में अमूर्तता प्राप्त की जाती है।

'सार' कीवर्ड का उपयोग करके एक वर्ग को एक सार वर्ग के रूप में घोषित किया जा सकता है। सार # में सार वर्ग हमेशा पदानुक्रम में आधार वर्ग है। जो चीज उन्हें अन्य वर्ग से अलग बनाती है, वह यह है कि उन्हें त्वरित नहीं किया जा सकता है। एक C # सार वर्ग को विरासत में प्राप्त करने की आवश्यकता है।

उदाहरण:

class Program { static void Main(string() args) { Hyundai hyn = new Hyundai(); String descp = hyn.Describe(); Console.WriteLine(descp); Console.ReadKey(); } } abstract class Car { public void Describe() { return 'Description of the car'; } } class Hyundai : Car { }

निम्नलिखित का आउटपुट है:

Description of the car

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

class Program { static void Main(string() args) { Hyundai hyn = new Hyundai(); String descp = hyn.Describe(); Console.WriteLine(descp); Console.ReadKey(); } } abstract class Car { public virtual string Describe() { return 'Description of the car'; } } class Hyundai : Car { public override string Describe() { return 'Description of the car is now Hyundai'; } }

इसलिए, यदि आप इस कोड को अभी निष्पादित करते हैं, तो यह निम्नलिखित आउटपुट देगा:

Description of the car is now Hyundai

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

यदि आप बारीकी से देखते हैं, तो आप देख सकते हैं कि अमूर्त वर्ग में हमारी विवरण पद्धति में कोई कार्यान्वयन नहीं है।

फिर, हम खाली तरीकों को क्यों परिभाषित कर रहे हैं?

ऐसा इसलिए है क्योंकि एक सार वर्ग विधियों का एक हस्ताक्षर प्रदान करता है और यह उपवर्गों के लिए इन सभी तरीकों के लिए एक कार्यान्वयन बनाने के लिए एक दायित्व बनाता है। यह बेस क्लास को साझा करने की अनुमति देता है, लेकिन साथ ही, यह व्युत्पन्न वर्ग के विधि कार्यान्वयन पर एक जांच भी रखता है।

इंटरफेस

C # में, इंटरफ़ेस एक वर्ग का खाका है। इंटरफ़ेस एक अमूर्त वर्ग के समान है और इसका उपयोग सौ प्रतिशत अमूर्तता प्राप्त करने के लिए किया जाता है। इंटरफ़ेस के अंदर वर्णित सभी विधियां डिफ़ॉल्ट रूप से अमूर्त हैं। इसमें कोई विधि निकाय नहीं है और इसे तत्काल नहीं किया जा सकता है।

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

उदाहरण:

class Program { static void Main(string() args) { Hyundai hyn = new Hyundai(); String descp = hyn.Describe(); Console.WriteLine(descp); Console.ReadKey(); } } interface Car { string Describe(); } class Hyundai : Car { public string Describe() { return 'Description of the car is now Hyundai'; } }

उपरोक्त कोड का आउटपुट होगा:

Description of the car is now Hyundai

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

निष्कर्ष

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

सी # में एनकैप्सुलेशन उपयोगकर्ता को कक्षा और उसके सदस्यों की दृश्यता स्थापित करने की अनुमति देता है। बहुरूपता तरीकों को एक ही नाम रखने की अनुमति देता है लेकिन एक ही वर्ग के अंदर या एक ही वर्ग में एक ही पैरामीटर के साथ अलग-अलग पैरामीटर।

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

समेकित कार्यक्रम

class Program { void print(int i, int j) { Console.WriteLine('Printing int: {0}', (i + j)); } void print(string a, string b) { Console.WriteLine('Printing String '+ a + b); } static void Main(string() args) { Program prog = new Program(); // Call print for sum of integers prog.print(5, 6); // Call to concatenate strings prog.print('Hello', 'World'); Hyundai hyn = new Hyundai(); String descp = hyn.Describe(); Console.WriteLine(descp); Console.ReadKey(); } } abstract class Car { public virtual string Describe() { return 'Description of the car'; } } class Hyundai : Car { public override string Describe() { return 'Description of the car is now Hyundai'; } }

=> यहाँ सी # प्रशिक्षण ट्यूटोरियल की पूरी श्रृंखला का अन्वेषण करें

अनुशंसित पाठ

^