जावा में एनकैप्सुलेशन

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

अब बात करते हैं जानकारी छुपाने की

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

public class Vehicle {

   public void gas() {

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

   public void brake() {

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

   public static void main(String[] args) {

       Vehicle vehicle = new Vehicle();

       // How everything looks to the user

       // Press one pedal, the car moves
       vehicle.gas();

       // Press the other pedal, the car brakes
       vehicle.brake();
   }
}

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

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. कोड परिवर्तन उपयोगकर्ताओं को प्रभावित नहीं करते हैं। हम विधियों के अंदर सभी परिवर्तन करते हैं। यह उपयोगकर्ताओं को प्रभावित नहीं करता है: उन्होंने गैस लगाने के लिए Vehicle.gas() लिखा था , और यही वे करते रहेंगे। तथ्य यह है कि हमने गैस () विधि के अंदर कुछ बदल दिया है अदृश्य रहता है: पहले की तरह, वे केवल आवश्यक परिणाम प्राप्त करते हैं।