ओओपी सिद्धांत

नमस्ते! आज के पाठ में हम वस्तु-उन्मुख प्रोग्रामिंग के सिद्धांतों के बारे में बात करेंगे। क्या आपने कभी सोचा है कि जावा को बिल्कुल वैसा ही क्यों बनाया गया है जैसा वह है? मेरा मतलब है, आप कक्षाओं की घोषणा करते हैं और कक्षाओं के आधार पर वस्तुओं का निर्माण करते हैं, कक्षाओं में विधियाँ आदि होती हैं, लेकिन भाषा को संरचित क्यों किया जाता है ताकि कार्यक्रमों में कक्षाएं और वस्तुएँ हों, न कि कुछ और? एक "ऑब्जेक्ट" की अवधारणा का आविष्कार क्यों किया गया और इसे सबसे आगे रखा गया? क्या सभी भाषाओं को इस तरह से डिज़ाइन किया गया है? यदि नहीं, तो यह Java को क्या लाभ देता है? जैसा कि आप देख सकते हैं, बहुत सारे प्रश्न हैं :) आइए आज के पाठ में उनमें से प्रत्येक का उत्तर देने का प्रयास करें।

ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग (OOP) क्या है?

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

Begin
	Class Rectangle (Width, Height); Real Width, Height;
			           
	 Begin
	    Real Area, Perimeter;  
	 
	    Procedure Update;      
	    Begin
	      Area := Width * Height;
              OutText("Rectangle is updating, Area = "); OutFix(Area,2,8); OutImage;
	      Perimeter := 2*(Width + Height);
              OutText("Rectangle is updating, Perimeter = "); OutFix(Perimeter,2,8); OutImage;
	    End of Update;
	 
	    Update;               
	    OutText("Rectangle created: "); OutFix(Width,2,6);
	    OutFix(Height,2,6); OutImage;
	 End of Rectangle;

       Rectangle Class ColouredRectangle (Color); Text Color;
			           
	Begin   	  
	    OutText("ColouredRectangle created, color = "); OutText(Color);
	    OutImage;
        End of ColouredRectangle;

 
      	 Ref(Rectangle) Cr;            
	 Cr :- New ColouredRectangle(10, 20, "Green"); 
End;

यह कोड सैंपल कोड Weekly-geekly द्वारा "Simula - 50 Years of OOP" से लिया गया था। जैसा कि आप देख सकते हैं, जावा अपने दादाजी से बहुत अलग नहीं है :) यह इस तथ्य के कारण है कि सिमुला की उपस्थिति ने एक नई अवधारणा के जन्म को चिह्नित किया: ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग। विकिपीडिया ओओपी को इस तरह परिभाषित करता है: "ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग (ओओपी) एक प्रोग्रामिंग प्रतिमान है जो "ऑब्जेक्ट्स" की अवधारणा पर आधारित है, जिसमें फ़ील्ड के रूप में डेटा हो सकता है (अक्सर विशेषताओं के रूप में जाना जाता है), और कोड, फॉर्म में प्रक्रियाओं की (अक्सर विधियों के रूप में जाना जाता है)। मेरी राय में, यह वास्तव में अच्छी परिभाषा है। कुछ समय पहले ही आपने जावा सीखना शुरू किया था, लेकिन इस परिभाषा में शायद ऐसा कोई शब्द नहीं है जिसे आप नहीं जानते :) आज OOP सबसे आम प्रोग्रामिंग पद्धति है। जावा के अलावा, OOP सिद्धांतों का उपयोग कई लोकप्रिय भाषाओं में किया जाता है जिनके बारे में आपने सुना होगा। उदाहरण के लिए, C++ (खेल विकास में सक्रिय रूप से उपयोग किया जाता है), Objective-C और Swift (Apple उपकरणों के लिए प्रोग्राम लिखने के लिए उपयोग किया जाता है), Python (मशीन लर्निंग में सबसे लोकप्रिय), PHP (सबसे लोकप्रिय वेब विकास भाषाओं में से एक), JavaScript ( यह कहना आसान है कि इसका क्या उपयोग नहीं किया जाता है) और कई अन्य। तो, वैसे भी OOP के सिद्धांत क्या हैं? हम आपको विस्तार से बताएंगे। वैसे भी ओओपी के सिद्धांत क्या हैं? हम आपको विस्तार से बताएंगे। वैसे भी ओओपी के सिद्धांत क्या हैं? हम आपको विस्तार से बताएंगे।

ओओपी सिद्धांत

ये नींव की नींव हैं। 4 मुख्य विशेषताएं जो एक साथ ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग प्रतिमान बनाती हैं। एक सफल प्रोग्रामर बनने के लिए उन्हें समझना जरूरी है।

सिद्धांत 1. वंशानुक्रम

अच्छी खबर: आप पहले से ही OOP के कुछ सिद्धांतों को जानते हैं! :) हम पहले ही पाठों में कई बार वंशानुक्रम का सामना कर चुके हैं, और हम इसका उपयोग करने में सफल रहे। विरासत एक तंत्र है जो आपको मौजूदा (मूल) वर्ग के आधार पर एक नई कक्षा का वर्णन करने देता है। ऐसा करने में, नई कक्षा मूल वर्ग की संपत्तियों और कार्यक्षमता को उधार लेती है। वंशानुक्रम क्या है और यह क्या लाभ प्रदान करता है? इन सबसे ऊपर, कोड का पुन: उपयोग। माता-पिता वर्गों में घोषित क्षेत्रों और विधियों का उपयोग वंश वर्गों में किया जा सकता है। यदि सभी प्रकार की कारों में 10 सामान्य फ़ील्ड और 5 समान विधियाँ हैं, तो आपको बस उन्हें ऑटो में ले जाने की आवश्यकता हैअभिभावक वर्ग। आप उन्हें वंशज वर्गों में बिना किसी समस्या के उपयोग कर सकते हैं। ठोस लाभ: दोनों मात्रात्मक (कम कोड) और, परिणामस्वरूप, गुणात्मक (कक्षाएं बहुत सरल हो जाती हैं)। इसके अलावा, वंशानुक्रम बहुत लचीला है - आप लिखने की अलग कार्यक्षमता जोड़ सकते हैं कि वंशज गायब हैं (कुछ फ़ील्ड या व्यवहार जो किसी विशेष वर्ग के लिए विशिष्ट हैं)। सामान्य तौर पर, वास्तविक जीवन की तरह, हम सभी अपने माता-पिता से कुछ हद तक मिलते-जुलते हैं, लेकिन कुछ हद तक उनसे अलग भी हैं :)

सिद्धांत 2। अमूर्त

यह एक बहुत ही सरल सिद्धांत है। अमूर्तता का अर्थ है किसी चीज़ की मुख्य, सबसे महत्वपूर्ण विशेषताओं की पहचान करना, साथ ही साथ किसी भी छोटी और महत्वहीन चीज़ को त्यागना। पहिए को फिर से लगाने की जरूरत नहीं है। आइए कक्षाओं के बारे में एक पुराने पाठ का एक उदाहरण याद करें। मान लीजिए हम कंपनी के कर्मचारियों के लिए फाइलिंग सिस्टम बना रहे हैं। "कर्मचारी" ऑब्जेक्ट बनाने के लिए, हमने एक कर्मचारी वर्ग लिखा है। कंपनी फाइलिंग सिस्टम में उनका वर्णन करने के लिए कौन सी विशेषताएँ महत्वपूर्ण हैं? नाम, जन्म तिथि, एसएसएन और कर्मचारी आईडी। लेकिन इस प्रकार के रिकॉर्ड के लिए हमें कर्मचारी की ऊंचाई, आंखों के रंग या बालों के रंग की आवश्यकता नहीं है। कंपनी को किसी कर्मचारी के बारे में ऐसी जानकारी की कोई आवश्यकता नहीं है। इसलिए, कर्मचारी वर्ग में, हम निम्नलिखित चर घोषित करते हैं:, int age , int socialSecurityNumber , और int EmployeesId । और हम आंखों के रंग जैसी अनावश्यक जानकारी को अलग कर देते हैं। हालांकि, अगर हम मॉडलिंग एजेंसी के लिए फाइलिंग सिस्टम बना रहे हैं, तो स्थिति नाटकीय रूप से बदल जाती है। एक मॉडल की ऊंचाई, आंखों का रंग और बालों का रंग महत्वपूर्ण विशेषताएं हैं, लेकिन उसका एसएसएन हमारे लिए बिल्कुल अप्रासंगिक है। तो, मॉडल वर्ग में , हम निम्नलिखित चर बनाते हैं: स्ट्रिंग ऊँचाई , स्ट्रिंग बाल , स्ट्रिंग आँखें ।

सिद्धांत 3. एनकैप्सुलेशन

हम पहले ही इसमें भाग चुके हैं। जावा में, एनकैप्सुलेशन का अर्थ डेटा को पढ़ने और बदलने की क्षमता को प्रतिबंधित करना है। जैसा कि आप देख सकते हैं, शब्द "कैप्सूल" शब्द पर आधारित है। हम कुछ महत्वपूर्ण डेटा को छिपाने के लिए "कैप्सूल" का उपयोग करेंगे जिसे हम नहीं चाहते कि दूसरे बदलें। यहाँ वास्तविक जीवन से एक सरल उदाहरण है। आपका एक प्रथम नाम और एक अंतिम नाम है। आपके सभी दोस्त उन्हें जानते हैं। लेकिन उनके पास आपका पहला या अंतिम नाम बदलने की क्षमता नहीं है। हम कह सकते हैं कि ऐसा करने की प्रक्रिया अदालत प्रणाली द्वारा "संपुटित" है: आप अपना अंतिम नाम केवल कोर्ट क्लर्क के माध्यम से बदल सकते हैं, और केवल आप ही इसे कर सकते हैं। अन्य "उपयोगकर्ताओं" के पास आपके पहले और अंतिम नाम तक "रीड-ओनली" पहुंच होती है :) एक और उदाहरण उदाहरण घर पर रखी नकदी है। इसे अपने कमरे के बीच में सादे दृष्टि से छोड़ना एक अच्छा विचार नहीं है। कोई भी "उपयोगकर्ता" (आपके घर आने वाला व्यक्ति) आपके पैसे की राशि को बदल सकेगा, यानी वह आपके पैसे ले सकता है। इसे तिजोरी में रखना बेहतर होगा। तब पहुंच केवल आपके लिए और केवल एक विशेष कोड का उपयोग करके उपलब्ध होगी। एनकैप्सुलेशन के स्पष्ट उदाहरण जिनके साथ आप पहले ही काम कर चुके हैं, वे हैं एक्सेस मॉडिफायर्स (निजी, सार्वजनिक, आदि), साथ ही सेटर्स और गेटर्स। यदि आप इनकैप्सुलेट नहीं करते हैंकैट क्लास का आयु क्षेत्र, फिर कोई भी लिख सकता है:

Cat.age = -1000;

एनकैप्सुलेशन मैकेनिज्म हमें आयु क्षेत्र को एक सेटर विधि से सुरक्षित करने देता है, जहाँ हम यह सुनिश्चित कर सकते हैं कि आयु को ऋणात्मक संख्या में सेट नहीं किया जा सकता है।

सिद्धांत 4. बहुरूपता

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

public class Animal {

   public void speak() {
      
       System.out.println("Hello!");
   }
}

public class Dog extends Animal {
  
   @Override
   public void speak() {
       System.out.println ("Woof-woof!");
   }
}

public class Cat extends Animal {

   @Override
   public void speak() {
       System.out.println("Meow!");
   }
}

अब हम एक एनिमल रेफरेंस वेरिएबल डिक्लेयर करने की कोशिश करेंगे और उसे एक डॉग ऑब्जेक्ट असाइन करेंगे।

public class Main {

   public static void main(String[] args) {

       Animal dog = new Dog();
       dog.speak();
   }
}

आपको क्या लगता है कि किस विधि को बुलाया जाएगा? एनिमल.स्पीक () या डॉग.स्पीक () ? डॉग क्लास में विधि कहलाएगी: वूफ-वूफ! हमने एक एनिमल रेफरेंस बनाया , लेकिन ऑब्जेक्ट डॉग की तरह व्यवहार करता है । यदि आवश्यक हो, तो यह बिल्ली, घोड़े या किसी अन्य जानवर की तरह व्यवहार कर सकता है। महत्वपूर्ण बात यह है कि सामान्य पशु संदर्भ चर के लिए एक विशिष्ट उपवर्ग निर्दिष्ट करना है। यह समझ में आता है, क्योंकि सभी कुत्ते जानवर हैं। हमारे मन में यही था जब हमने कहा "वस्तुओं का व्यवहार उनके प्रकार के आधार पर भिन्न होगा।" अगर हमने कैट ऑब्जेक्ट बनाया है ...

public static void main(String[] args) {

   Animal cat = new Cat();
   cat.speak();
}

स्पीक () विधि "म्याऊ!" प्रदर्शित करेगी। लेकिन 'कई प्रकारों के साथ काम करने की क्षमता जैसे कि वे एक ही प्रकार के हों' से हमारा क्या तात्पर्य है? यह भी काफी सीधा है। आइए कल्पना करें कि हम जानवरों के लिए नाई की दुकान बना रहे हैं। हमारी नाई की दुकान किसी भी जानवर को ट्रिम करने में सक्षम होनी चाहिए, इसलिए हम एनिमल पैरामीटर (जानवर को बाल कटवाना) के साथ ट्रिम () विधि बनाते हैं।

public class AnimalBarbershop {

   public void trim(Animal animal) {

       System.out.println("The haircut is done!"); 
   }
}

और अब हम बिल्ली और कुत्ते की वस्तुओं को ट्रिम () विधि में पास कर सकते हैं !

public static void main(String[] args) {

   Cat cat = new Cat();
   Dog dog = new Dog();

   AnimalBarbershop barbershop = new AnimalBarbershop();

   barbershop.trim(cat);
   barbershop.trim(dog);
}

और यहाँ स्पष्ट उदाहरण है: AnimalBarbershop वर्ग बिल्ली और कुत्ते के प्रकारों के साथ काम करता है जैसे कि वे एक ही प्रकार के हों। उसी समय, बिल्ली और कुत्ते के अलग-अलग व्यवहार होते हैं: वे प्रत्येक अलग तरह से बोलते हैं।

हमें ओओपी की आवश्यकता क्यों है?

OOP कभी एक नई प्रोग्रामिंग अवधारणा के रूप में क्यों उभरा? प्रोग्रामर के पास क्रियात्मक उपकरण थे, जैसे प्रक्रियात्मक भाषाएँ। किस बात ने उन्हें मौलिक रूप से कुछ नया आविष्कार करने के लिए प्रेरित किया? इन सबसे ऊपर, उन कार्यों की जटिलता जिनका उन्होंने सामना किया। यदि 60 साल पहले प्रोग्रामर का कार्य "कुछ गणितीय अभिव्यक्ति का मूल्यांकन" जैसा कुछ था, तो अब यह कुछ ऐसा हो सकता है जैसे "गेम STALKER के लिए 7 अलग-अलग अंत लागू करें, जो खिलाड़ी के A, B, C, DE पर किए गए निर्णयों के संयोजन पर निर्भर करता है। , और खेल में एफ।" जैसा कि आप देख सकते हैं, पिछले दशकों में कार्य स्पष्ट रूप से अधिक जटिल हो गए हैं। और परिणामस्वरूप, डेटा प्रकार अधिक जटिल हो गए हैं। यह एक और कारण है कि OOP दिखाई दिया। साधारण आदिम का उपयोग करके एक गणितीय अभिव्यक्ति का आसानी से मूल्यांकन किया जा सकता है। यहां किसी वस्तु की जरूरत नहीं है। लेकिन कस्टम कक्षाओं का उपयोग किए बिना खेल के अंत के साथ कार्य का वर्णन करना भी मुश्किल होगा। उस ने कहा, कक्षाओं और वस्तुओं का उपयोग करके इसका वर्णन करना काफी आसान है। जाहिर है, हमें कई वर्गों की आवश्यकता होगी: गेम, स्टॉकर, एंडिंग, प्लेयरडिसीजन, गेमइवेंट, और इसी तरह। दूसरे शब्दों में, यहां तक ​​कि समस्या को हल करना शुरू किए बिना भी, हम आसानी से अपने दिमाग में समाधान का "चित्रण" कर सकते हैं। कार्यों की बढ़ती जटिलता ने प्रोग्रामरों को उन्हें भागों में विभाजित करने के लिए मजबूर किया। लेकिन प्रक्रियात्मक प्रोग्रामिंग में ऐसा करना इतना आसान नहीं था। और अक्सर एक कार्यक्रम एक पेड़ की तरह होता था जिसमें बहुत सारी शाखाएँ सभी संभावित निष्पादन पथों का प्रतिनिधित्व करती थीं। कुछ शर्तों के आधार पर, कार्यक्रम की एक या दूसरी शाखा को निष्पादित किया गया था। छोटे कार्यक्रमों के लिए यह सुविधाजनक था, लेकिन एक बड़ी समस्या को भागों में विभाजित करना बहुत कठिन था। यह OOP के उभरने का एक और कारण था। इस प्रतिमान ने प्रोग्रामर को प्रोग्राम को "मॉड्यूल" (कक्षाओं) के एक समूह में विभाजित करने की क्षमता दी, जिनमें से प्रत्येक कार्य का अपना हिस्सा करता है। सभी ऑब्जेक्ट आपस में बातचीत करके हमारे प्रोग्राम के काम को पूरा करते हैं। इसके साथ ही हम प्रोग्राम में कहीं और अपने कोड का पुन: उपयोग कर सकते हैं, जिससे समय की भी काफी बचत होती है।