oop ट्यूटोरियल
शुरुआत ऊप से हो रही है

टिप्पणियों

परिचय

OOP - ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग इन दिनों एक व्यापक रूप से उपयोग की जाने वाली प्रोग्रामिंग प्रतिमान है। OOP में, हम प्रोग्राम और ऑब्जेक्ट्स का उपयोग करके वास्तविक विश्व की समस्याओं को मॉडल करते हैं, ताकि उन्हें हल करने के लिए, प्रोग्रामेटिक रूप से।

चार मुख्य OOP अवधारणाएं हैं

1. विरासत
2. बहुरूपता
3. मतिहीनता
4. encapsulation

इन चार अवधारणाओं को एक साथ OOP में कार्यक्रमों को विकसित करने के लिए उपयोग किया जाता है।

विभिन्न भाषाएँ हैं जो ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग का समर्थन करती हैं। सबसे लोकप्रिय भाषाएं हैं

• सी ++
• जावा
• सी#
• पायथन (पायथन पूरी तरह से ऑब्जेक्ट ओरिएंटेड नहीं है, लेकिन इसकी अधिकांश OOP विशेषताएं हैं)

OOP परिचय

Intoduction

ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग (ज्यादातर OOP के रूप में संदर्भित) समस्याओं को हल करने के लिए एक प्रोग्रामिंग प्रतिमान है।
सौंदर्य एक OO (ऑब्जेक्ट ओरिएंटेड) प्रोग्राम, यह है कि हम प्रोग्राम के बारे में सोचते हैं कि वस्तुओं के एक समूह के रूप में विशिष्ट आदेशों के बाद एक अनुक्रमिक स्क्रिप्ट के रूप में एक-दूसरे के साथ संवाद कर रहे हैं।

बहुत सारी प्रोग्रामिंग भाषाएं हैं जो OOP का समर्थन करती हैं, जिनमें से कुछ लोकप्रिय हैं:

• जावा
• सी ++
• सी#

अजगर को OOP का समर्थन करने के लिए भी जाना जाता है लेकिन इसमें कुछ गुणों का अभाव है।

ओओपी शब्दावली

OOP में सबसे बुनियादी शब्द एक वर्ग है ।
एक वर्ग मूल रूप से एक वस्तु है , जिसमें एक राज्य है और यह अपने राज्य के अनुसार काम करता है।

एक और महत्वपूर्ण शब्द एक उदाहरण है ।
एक वर्ग के बारे में सोचें जिसका उपयोग स्वयं के उदाहरण बनाने के लिए उपयोग किए जाने वाले टेम्पलेट के रूप में किया जाता है। वर्ग एक टेम्पलेट है और उदाहरण (ओं) ठोस वस्तुओं है।

कक्षा ए से निर्मित एक उदाहरण को आमतौर पर 'टाइप ए' के रूप में संदर्भित किया जाता है, ठीक उसी तरह जैसे 5 का प्रकार इंट और "एबीसीडी" का प्रकार एक स्ट्रिंग है ।

प्रकार (वर्ग) ClassA का एक उदाहरण नामित insance1 बनाने का एक उदाहरण:

जावा

ClassA instance1 = new ClassA();

सी ++

ClassA instance1;

या

ClassA *instance1 = new ClassA(); # On the heap

अजगर

instance1 = ClassA()

जैसा कि आप ऊपर दिए गए उदाहरण में देख सकते हैं, सभी मामलों में वर्ग का नाम उल्लेख किया गया था और इसके बाद खाली कोष्ठक थे (सी ++ को छोड़कर जहां अगर वे कोष्ठक खाली हैं तो गिराया जा सकता है)। इन कोष्ठकों में हम अपने वर्ग के कंस्ट्रक्टर को arguments दे सकते हैं।

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

प्रकार (वर्ग) क्लासबी के बी 1 नामक एक उदाहरण बनाने का एक उदाहरण। ClassB का निर्माता एक प्रकार का तर्क लेता है int :

जावा

ClassA instance1 = new ClassA(5);

या

int i = 5;
ClassA instance1 = new ClassA(i);

सी ++

ClassA instance1(5);

अजगर

instance1 = ClassA(5)

जैसा कि आप देख सकते हैं, एक फंक्शन बनाने की प्रक्रिया एक फ़ंक्शन को कॉल करने की प्रक्रिया के समान है।

कार्य बनाम विधियां

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

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

जावा में, एक फ़ंक्शन में इसकी परिभाषा में स्थिर शब्द है, जैसे:

// File's name is ClassA
public static int add(int a, int b) {
    return a + b;
}

इसका मतलब है कि आप इसे स्क्रिप्ट में कहीं से भी कॉल कर सकते हैं।

// From the same file
System.out.println(add(3, 5));

// From another file in the same package (or after imported)
System.out.println(ClassA.add(3, 5));

जब हम फ़ंक्शन को किसी अन्य फ़ाइल से कॉल करते हैं तो हम कक्षा के नाम का उपयोग करते हैं (जावा में यह फ़ाइल का नाम भी है) यह उसी से संबंधित है, यह अंतर्ज्ञान देता है कि फ़ंक्शन वर्ग से संबंधित है और इसके किसी भी उदाहरण से नहीं।

इसके विपरीत, हम तो जैसे ClassA में एक mehod परिभाषित कर सकते हैं:

// File's name is ClassA
public int subtract(int a, int b){
    return a - b;
}

इस घोषणा के बाद हम इस विधि को इस प्रकार कह सकते हैं:

ClassA a = new ClassA();
System.out.println(a.subtract(3, 5));

यहां हमें इसकी विधि को घटाना कहने के लिए ClassA का एक उदाहरण बनाने की आवश्यकता थी। ध्यान दें कि हम निम्नलिखित कार्य नहीं कर सकते हैं :

System.out.println(ClassA.subtract(3, 5));

यह लाइन एक संकलन त्रुटि उत्पन्न करेगी, जिसकी शिकायत हमने बिना उदाहरण के इस गैर-स्थैतिक विधि से की।

एक वर्ग की स्थिति का उपयोग करना

मान लें कि हम अपनी घटाव विधि को फिर से लागू करना चाहते हैं, लेकिन इस बार हम हमेशा एक ही संख्या (प्रत्येक उदाहरण के लिए) को घटाना चाहते हैं। हम निम्न वर्ग बना सकते हैं:

class ClassB {

    private int sub_amount;

    public ClassB(int sub_amount) {
        this.sub_amount = sub_amount;
    }

    public int subtract(int a) {
        return a - sub_amount;
    }

    public static void main(String[] args) {
        ClassB b = new ClassB(5);
        System.out.println(b.subtract(3)); // Ouput is -2
    }
}

जब हम इस कोड चलाने के लिए, वर्ग ClassB का एक नया उदाहरण नामित ख बनाई गई है और इसके निर्माता मूल्य 5 के साथ तंग आ गया है।
कंस्ट्रक्टर अब दिए गए सब_माउंट को लेता है और इसे अपने निजी क्षेत्र के रूप में संग्रहीत करता है, जिसे सब_माउंट भी कहा जाता है (यह कन्वेंशन जावा में बहुत जाना जाता है, तर्कों को खेतों के नाम से जाना जाता है)।
उसके बाद, हम 3 के मूल्य के साथ b पर घटाना विधि को कॉल करने के परिणामस्वरूप कंसोल पर प्रिंट करते हैं।

ध्यान दें कि घटाव के कार्यान्वयन में हम इसका उपयोग नहीं करते हैं this. कंस्ट्रक्टर में पसंद है।
जावा में, this केवल तब लिखा जाना चाहिए जब उस दायरे में परिभाषित समान नाम के साथ कोई अन्य चर हो। वही अजगर के self साथ काम करता है।
इसलिए जब हम सबट्रैक्शन में सब_माउंट का उपयोग करते हैं, तो हम निजी क्षेत्र का संदर्भ देते हैं जो प्रत्येक वर्ग के लिए अलग होता है।

एक और उदाहरण पर जोर देना।
आइए उपरोक्त कोड में मुख्य फ़ंक्शन को निम्नलिखित में बदलें:

ClassB b1 = new ClassB(1);
ClassB b2 = new ClassB(2);

System.out.println(b1.subtract(10)); // Output is 9
System.out.println(b2.subtract(10)); // Output is 8

जैसा कि हम देख सकते हैं, बी 1 और बी 2 स्वतंत्र हैं और प्रत्येक की अपनी स्थिति है ।

इंटरफेस और वंशानुक्रम

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

interface Printalbe {
    public void print();
}

Printalbe इंटरफ़ेस प्रिंट नामक एक विधि को परिभाषित करता है, लेकिन यह इसके कार्यान्वयन (जावा के लिए बहुत अजीब) नहीं देता है। हर वर्ग जो रूप में खुद को वाणी implementing इस इंटरफेस ड्रा विधि के लिए एक कार्यान्वयन प्रदान करनी चाहिए। उदाहरण के लिए:

class Person implements Printalbe {

    private String name;

    public Person(String name) {
        this.name = name;
    }

    public void print() {
        System.out.println(name);
    }
}

यदि व्यक्ति ड्रॉबल को लागू करने के लिए खुद को घोषित करेगा, लेकिन प्रिंट करने के लिए कार्यान्वयन प्रदान नहीं करता है, तो संकलन त्रुटि होगी और कार्यक्रम संकलित नहीं होगा।

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

class AgedPerson extends Person {

    private int age;

    public AgedPerson(String name, int age) {
        super(name);
        this.age = age;
    }

    public void print() {
        System.out.println("Name: " + name + ", age:" + age);
    }
}

कुछ नई चीजें चल रही हैं:

• हम बचाया शब्द का इस्तेमाल किया extends (ताकि हम घोषित करने के लिए की जरूरत नहीं है मुद्रण योग्य करने के लिए इसके कार्यान्वयन और यह भी, हम व्यक्ति से इनहेरिट कर रहे हैं इंगित करने के लिए implementing Printable फिर से)।
• हमने व्यक्ति के कंस्ट्रक्टर को कॉल करने के लिए super शब्द का उपयोग किया।
• हमने एक नए व्यक्ति की प्रिंट विधि को ओवरराइड किया।

यह बहुत जावा तकनीकी हो रहा है तो मैं इस विषय में किसी भी गहराई में नहीं जाऊंगा। लेकिन मैं उल्लेख करूंगा कि बहुत सारे चरम मामले हैं जिनका उपयोग करने से पहले विरासत और इंटरफेस के बारे में जानना चाहिए। उदाहरण के लिए कौन से तरीके और कार्य विरासत में मिले हैं? एक वर्ग से विरासत में मिलने पर निजी / सार्वजनिक / संरक्षित क्षेत्रों का क्या होता है? और इसी तरह।

सार वर्ग

एक अमूर्त वर्ग OOP में बहुत उन्नत शब्द है जो इंटरफेस और विरासत दोनों के संयोजन का वर्णन करता है। यह आपको एक वर्ग लिखने देता है, जिसमें कार्यान्वित और अनुपयोगी तरीके / कार्य शामिल हैं। जावा में यह कीवर्ड abstract का उपयोग करके किया जाता है और मैं इसे और अधिक नहीं समझाऊंगा कि एक त्वरित उदाहरण:

abstract class AbstractIntStack {

    abstract public void push(int element);

    abstract public void pop();

    abstract public int top();

    final public void replaceTop(int element) {
        pop();
        push(element);
    }
}

नोट: final कीवर्ड बताता है कि जब आप इस वर्ग से इनहेरिट करते हैं तो आप इस विधि को ओवरराइड नहीं कर सकते। यदि किसी वर्ग को अंतिम घोषित किया जाता है, तो कोई भी वर्ग उससे बिल्कुल भी विरासत में नहीं मिल सकता है।