क्या आप प्रक्रियात्मक प्रोग्रामिंग और ओओपी के बीच अंतर बता सकते हैं?


जवाब 1:

मूल प्रश्न:

क्या आप प्रक्रियात्मक प्रोग्रामिंग और ओओपी के बीच अंतर बता सकते हैं?

उत्तर:

पहले चीजें पहले, आइए परिभाषित करें कि प्रक्रियात्मक और ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग क्या है।

परिभाषा - प्रक्रियात्मक भाषा का क्या अर्थ है? एक प्रक्रियात्मक भाषा एक प्रकार की कंप्यूटर प्रोग्रामिंग भाषा है जो एक कार्यक्रम की रचना करने के लिए प्रोग्रामिंग प्रोग्रामिंग के भीतर अच्छी तरह से संरचित चरणों और प्रक्रियाओं की एक श्रृंखला को निर्दिष्ट करती है। इसमें एक कम्प्यूटेशनल कार्य या कार्यक्रम को पूरा करने के लिए बयानों, कार्यों और आदेशों का एक व्यवस्थित क्रम होता है। प्रक्रियात्मक भाषा को अनिवार्य भाषा के रूप में भी जाना जाता है। टेकपीडिया प्रोसेरुरल लैंग्वेज की प्रक्रियात्मक भाषा बताती है, जैसा कि नाम का अर्थ है, पूर्वनिर्धारित और सुव्यवस्थित प्रक्रियाओं से संबंधित है, कार्य या प्रोग्राम के आर्किटेक्चर में उप-रूटीन उन सभी चरणों को निर्दिष्ट करता है जो कंप्यूटर को एक वांछित स्थिति या आउटपुट तक पहुंचाने के लिए होना चाहिए। प्रक्रियात्मक भाषा चर, कार्यों, बयानों और सशर्त ऑपरेटरों के भीतर एक कार्यक्रम को अलग करती है। कार्य करने के लिए डेटा और चर पर प्रक्रियाएं या कार्य कार्यान्वित किए जाते हैं। इन प्रक्रियाओं को कार्यक्रम पदानुक्रम के बीच कहीं भी बुलाया जा सकता है / आमंत्रित किया जा सकता है, और साथ ही अन्य प्रक्रियाओं द्वारा भी। प्रक्रियात्मक भाषा में लिखे गए प्रोग्राम में एक या अधिक प्रक्रियाएँ होती हैं। प्रक्रियात्मक भाषा उपयोग में आने वाली सबसे सामान्य प्रकार की प्रोग्रामिंग भाषाओं में से एक है, जिसमें C / C ++, Java, ColdFusion और PASCAL जैसी उल्लेखनीय भाषाएँ शामिल हैं।

अब, ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग को परिभाषित करते हैं।

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

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

अभी। आइए अंतर कार्यान्वयन वार को देखें।

हम प्रक्रियात्मक के साथ शुरू करेंगे, और ऐसा करने का सबसे आसान तरीका यह होगा कि सी भाषा का उपयोग विशेष रूप से अर्डुइनो के साथ किया जाए क्योंकि मुझे पता है।

मैंने आधार के रूप में ब्लिंकिंग लाइट ट्यूटोरियल का उपयोग करने का फैसला किया क्योंकि यह मूल कार्यान्वयन में से एक है।

// सेटअप फ़ंक्शन तब चलता है जब आप रीसेट दबाते हैं या बोर्ड शून्य सेटअप () {// डिजिटल पिन LED_BUILTIN को आउटपुट के रूप में प्रारंभ करते हैं। पिनमोड (LED_BUILTIN, OUTPUT); } // लूप फंक्शन हमेशा के लिए लूप को बार-बार चलाता है () {digitalWrite (LED_BUILTIN, HIGH); // एलईडी चालू करें (उच्च वोल्टेज स्तर है) देरी (1000); // एक दूसरे digitalWrite (LED_BUILTIN, LOW) की प्रतीक्षा करें; // वोल्टेज को कम करके एलईडी को बंद करें देरी (1000); // एक दूसरे के लिए प्रतीक्षा करें}

अब, मैं कोड को थोड़ा बेहतर समझाता हूं। आपके पास दो फ़ंक्शन सेटअप और लूप हैं। लूप को बार-बार कहा जाता है और सेटअप को केवल एक बार कहा जाता है। आप डिजिटल रेटिंग को एलईडी को क्रमशः उच्च और निम्न में बिजली की रेटिंग डालने के लिए भेजते हैं। विलंब है कि प्रकाश कितनी देर तक चालू या बंद रहेगा, इस मामले में, 1000ms या लगभग 1 सेकंड। बहुत सीधे आगे, लेकिन इससे पता चलता है कि आप प्रक्रियात्मक प्रोग्रामिंग के आवश्यक हैं। आप एक प्रक्रिया या निर्देश लिखते हैं और इसे समाप्त होने तक दोहराया जाता है। आवश्यक कोड के लिए कोई अतिरिक्त जटिलता नहीं है।

C # और OOP उदाहरण समय।

सिस्टम का उपयोग; System.Collections.Generic का उपयोग कर; System.Linq का उपयोग करना; System.Text का उपयोग कर; नाम स्थान oops {सार्वजनिक वर्ग के ग्राहक {// सदस्य चर सार्वजनिक int CustID; सार्वजनिक स्ट्रिंग नाम; सार्वजनिक स्ट्रिंग पता; // फ़ील्ड ग्राहक को शुरू करने के लिए अवरोधक () {CustID = 1101; नाम = "टॉम"; पता = "संयुक्त राज्य अमेरिका"; } // ग्राहक रिकॉर्ड (कार्यक्षमता) सार्वजनिक शून्य प्रदर्शन दिखाने के लिए विधि () {Console.WriteLine ("ग्राहक =" + CustID); Console.WriteLine ( "नाम =" + नाम); Console.WriteLine ( "पता =" + पता); } // प्रवेश बिंदु के लिए कोड}} क्लास प्रोग्राम {स्टैटिक वोड मेन (स्ट्रिंग [] args) {// ऑब्जेक्ट इंस्टेंटेशन ग्राहक obj = नया ग्राहक (); // मेथड कॉलिंग obj.displayData (); // Console.WriteLine (obj.CustID) को कॉल करने वाले फ़ील्ड; Console.WriteLine (obj.Name); Console.WriteLine (obj.Address); }}}

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


जवाब 2:

OOPS Concept in Java

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


जवाब 3:

प्रक्रियात्मक प्रोग्रामिंग प्राथमिक अमूर्त तंत्र के रूप में प्रक्रियाओं के साथ प्रोग्रामिंग है। हुह।

एक प्रक्रिया क्या है? यह कोड की एक नामित गांठ है जिसे नाम से लागू किया जा सकता है, और जो उस संदर्भ से मान और संदर्भ प्राप्त करता है जहां इसे लागू किया जाता है, पैरामीटर, और कुछ काम करने के बाद उस संदर्भ में मान और संदर्भ वापस कर सकते हैं।

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

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

अगर (स्थिति) {doThisThing ()} और {doThatThing ()}

तथा

जबकि (स्थिति) {KeepOnDoingThisThing ()}

मुझे लगता है कि अधिकांश प्रोग्रामर के दिमाग में, "संरचित प्रोग्रामिंग" के साथ "प्रक्रियात्मक" प्रोग्रामिंग बहुत अधिक उलझी हुई है। उस दिन वापस जब संरचित प्रोग्रामिंग नई थी, यह पाया गया कि प्रवाह-नियंत्रण नियंत्रणों का एक सुविधाजनक सेट है जिसमें से एक प्रक्रिया के भीतर प्रवाह-नियंत्रण के सभी आवश्यक पैटर्न का निर्माण किया जा सकता है:

विकल्प चुनना

  • यदि फिर (दो विकल्प, बूलियन पर आधारित) केस या स्विच (कई विकल्प, किसी भी सेट पर आधारित)

दुहराव

ज्ञात सीमा के साथ:

  • लूप्स के लिए (आमतौर पर दिए गए पुनरावृत्तियों की संख्या) फॉर्च लूप्स (कुछ संग्रह के आकार के रूप में कई बार पुनरावृति, शायद सदस्यों के ऊपर)

तदर्थ सीमा के साथ:

  • जबकि (0 या अधिक पुनरावृत्तियों) करते हैं (1 या अधिक पुनरावृत्तियों)

और दुखद अलोकप्रिय:

  • निकास-जब लूप

जो कम से कम एक बार बाहर निकलने से पहले कोड को निष्पादित करता है, और बाहर निकलने के शून्य या अधिक समय के बाद का कोड।

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

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

यदि आप एक कदम आगे जाते हैं और एक ही मॉड्यूल के कई उपयोगों की अनुमति देते हैं, प्रत्येक उपयोग के साथ मॉड्यूल में परिभाषित चर की अपनी प्रति होती है, तो मॉड्यूल एक आदिम प्रकार की वस्तु की तरह दिखाई देने लगता है। और अगर आप तब प्राथमिक चीजों को चर के साथ मॉड्यूल के उदाहरण बनाते हैं और उनके बीच की प्रक्रियाओं को किसी भी तरह साझा करते हैं, तो आपके पास केवल उन की एक प्रति है, तो आप C ++ क्या करते हैं, उसके बहुत करीब हैं। यह ठीक दानेदार मॉड्यूलर, प्रक्रियात्मक, संरचित प्रोग्रामिंग ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग नहीं है।

ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग प्राथमिक अमूर्त तंत्र के रूप में वस्तुओं के साथ प्रोग्रामिंग कर रहा है। हुह।

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

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

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

प्रोग्रामिंग, स्मॉलटाकल में, का अर्थ है स्क्रिप्टिंग संदेश का एक संयोजन तरीकों में जाने के लिए भेजता है, और रहने के तरीकों के लिए नई कक्षाएं (मेटाक्लासेस के साथ) बना रहा है। और यह प्रवाह-नियंत्रण के बराबर सच है क्योंकि यह कुछ भी है। अन्य।

एक प्रक्रियात्मक भाषा में आप एक संग्रह के प्रत्येक सदस्य पर कोड के साथ कुछ कार्रवाई कर सकते हैं जैसे कि यह छद्म कोड:

फ़ॉरच

एक सामान्य स्मॉलटॉक में संदेश भेजने की बराबर स्क्रिप्ट इस तरह दिख सकती है:

एलेक्शन करें: [aThing | aThing टेकशिपेशन]।

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

  • प्रक्रियात्मक कोड में, हम चुनते हैं कि संग्रह के सदस्यों को कैसे पार करना है, हम फॉर्च तंत्र का चयन करते हैं। ऑब्जेक्ट-ओरिएंटेड कोड में हम संग्रह को ट्रैवर्सल करने के लिए कहते हैं, हम नहीं जानते कि यह कैसे होता है। प्रक्रियात्मक कोड में, कॉलिंग कोड को doThisActionOn नाम की प्रक्रिया तक पहुंच होना चाहिए, ऑब्जेक्ट-ओरिएंटेड कोड takeTechAction में है सिर्फ एक प्रतीक। हमें नहीं पता कि संग्रह के अंदर की वस्तुएं इसकी व्याख्या कैसे करेंगी।

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