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

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

public class Auto {

   public void go() {

       /* Some complicated things happen inside the car.
       As a result, it moves forward */
   }

   public void brake() {

       /* Some complicated things happen inside the car.
       As a result, it slows down. */
   }

   public static void main(String[] args) {

       Auto auto = new Auto();

       // From the user's perspective,

       // one pedal is pressed and the car accelerates.
       auto.gas();
      
       // The other is pressed, and the car slows down.
       auto.brake();
   }
}

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

public class Cat {

   public String name;
   public int age;
   public int weight;

   public Cat(String name, int age, int weight) {
       this.name = name;
       this.age = age;
       this.weight = weight;
   }

   public Cat() {
   }

   public void sayMeow() {
       System.out.println("Meow!");
   }

  
}

शायद आपको पिछले पाठ से इस वर्ग की समस्या याद हो? अगर नहीं तो चलिए अब इसे याद करते हैं। समस्या यह है कि इसका डेटा (फ़ील्ड) सभी के लिए खुला है - एक अन्य प्रोग्रामर आसानी से 0 के वजन और -1000 वर्ष की आयु के साथ एक अनाम बिल्ली बना सकता है:

public static void main(String[] args) {

   Cat cat = new Cat();
   cat.name = "";
   cat.age = -1000;
   cat.weight = 0;

}

हो सकता है कि आप इस बात पर कड़ी नज़र रख सकें कि क्या आपके किसी सहकर्मी ने अमान्य स्थिति वाली वस्तुएँ बनाई हैं, लेकिन ऐसी "अमान्य वस्तुएँ" बनाने की संभावना को भी बाहर करना बेहतर होगा। निम्नलिखित तंत्र हमें डेटा छिपाने में मदद करते हैं:

1. एक्सेस संशोधक ( निजी , संरक्षित , पैकेज डिफ़ॉल्ट )
2. गेटर्स और सेटर्स

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

1. किसी वस्तु की सही स्थिति पर नियंत्रण। ऊपर इसके उदाहरण थे। एक सेटर और निजी संशोधक यह सुनिश्चित करते हैं कि हमारे कार्यक्रम में ऐसी बिल्लियाँ नहीं होंगी जिनका वजन 0 है।


2. एक इंटरफेस के माध्यम से उपयोगकर्ता के अनुकूल। बाहरी दुनिया के लिए केवल तरीकों को "उजागर" छोड़ दिया गया है। कॉल करने के तरीके परिणाम प्राप्त करने के लिए पर्याप्त हैं - वे कैसे काम करते हैं, इसके विवरण में तल्लीन करने की बिल्कुल आवश्यकता नहीं है।


3. कोड परिवर्तन उपयोगकर्ताओं को प्रभावित नहीं करते हैं। हम तरीकों के अंदर कोई भी और सभी बदलाव करते हैं। यह विधि के उपयोगकर्ता को प्रभावित नहीं करता है: यदि गैस पेडल लगाने के लिए सही कोड पहले "auto.gas ()" था, तो यह जारी रहेगा। तथ्य यह है कि हमने गैस () विधि के अंदर कुछ बदल दिया है, उपयोगकर्ता के लिए अदृश्य रहता है: पहले की तरह, कॉलर को केवल वांछित परिणाम प्राप्त होता है।