एन्कॅप्सुलेशनची तत्त्वे

हाय! चला आजचा धडा एन्कॅप्स्युलेशनला समर्पित करू आणि लगेच उदाहरणांसह सुरुवात करूया :) येथे तुमच्याकडे एक सामान्य सोडा मशीन आहे . मला तुमच्यासाठी एक प्रश्न आहे: ते कसे कार्य करते? तपशीलवार उत्तर देण्याचा प्रयत्न करा: कप कुठून येतो, अंतर्गत तापमान कसे राखले जाते, बर्फ कुठे साठवला जातो, कोणते सरबत घालायचे हे मशीनला कसे कळते इ. या प्रश्नांची उत्तरे कदाचित तुमच्याकडे नसतील. पुरेसे योग्य, कारण प्रत्येकजण अशी मशीन वापरत नाही. ते आजकाल इतके लोकप्रिय नाहीत. आणखी एक उदाहरण देण्याचा प्रयत्न करूया. असे काहीतरी जे तुम्ही दररोज अनेक वेळा वापरता. अरे, ही एक कल्पना आहे! गुगल सर्च इंजिन कसे आहे ते सांगाकार्य करते तुम्ही एंटर केलेल्या शब्दांशी संबंधित माहिती नक्की कशी शोधते? काही परिणाम उच्च रँक का आहेत आणि इतर नाहीत? जरी तुम्ही दररोज Google वापरत असलात तरी शक्यता आहे, तुम्हाला माहीत नाही. पण काही फरक पडत नाही. तुम्हाला हे माहित असण्याची गरज नाही. ते कसे कार्य करते याचा विचार न करता तुम्ही शोध इंजिनमध्ये क्वेरी प्रविष्ट करू शकता. सोडा कसा काम करतो हे जाणून घेतल्याशिवाय तुम्ही मशीनमधून सोडा खरेदी करू शकता. अंतर्गत ज्वलन इंजिन कसे कार्य करते हे समजून न घेता, आणि भौतिकशास्त्र अजिबात माहित नसताना, अगदी प्राथमिक शाळेच्या स्तरावरही तुम्ही कार चालवू शकता. हे सर्व शक्य आहे ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंगच्या मुख्य तत्त्वांपैकी एक: एन्कॅप्सुलेशन. ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग (OOP) वरील विविध लेख वाचून, तुमच्या लक्षात आले असेल की प्रोग्रामिंगमध्ये दोन सामान्य संकल्पना समाविष्ट आहेत: एन्कॅप्सुलेशन आणि लपवणे . आणि लेखक "एनकॅप्सुलेशन" हा शब्द एक गोष्ट आणि नंतर दुसरी गोष्ट वापरण्यासाठी वापरतात. आम्ही दोन्ही संज्ञा एक्सप्लोर करू जेणेकरून तुम्हाला संपूर्ण समज मिळेल. प्रोग्रामिंगमध्ये, एन्कॅप्युलेशनचा मूळ अर्थ डेटाचे बंडलिंग , त्या डेटावर चालणाऱ्या पद्धतींसह, एका युनिटमध्ये (म्हणजे "कॅप्सूल") आहे. Java मध्ये, वर्ग हे एन्कॅप्सुलेशनचे एकक आहे. वर्गामध्ये डेटा (फील्ड) आणि या डेटासह कार्य करण्याच्या पद्धती दोन्ही असतात.हे तुमच्यासाठी स्पष्टपणे योग्य दृष्टिकोन असल्यासारखे वाटू शकते, परंतु इतर प्रोग्रामिंग पॅराडाइम्समध्ये, सर्वकाही वेगळ्या पद्धतीने मांडले जाते. उदाहरणार्थ, फंक्शनल प्रोग्रामिंगमध्ये, डेटा त्यावरील ऑपरेशन्सपासून काटेकोरपणे विभक्त केला जातो. 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();
   }
}

Java प्रोग्राममध्ये अंमलबजावणी लपवणे कसे दिसते ते येथे आहे. हे अगदी वास्तविक जीवनाप्रमाणेच आहे: वापरकर्त्यास इंटरफेस (पद्धती) प्रदान केला जातो. कृती करण्यासाठी वापरकर्त्याला प्रोग्राममध्ये कारची आवश्यकता असल्यास, तो किंवा ती फक्त इच्छित पद्धत कॉल करते. या पद्धतींमध्ये काय होते ते अनावश्यक आहे. महत्त्वाचे म्हणजे सर्वकाही जसे पाहिजे तसे कार्य करते. येथे आपण अंमलबजावणी लपविण्याबद्दल बोलत आहोत . त्याशिवाय, Java मध्ये डेटा लपविण्याची सुविधा देखील आहे . आम्ही गेटर्स आणि सेटरच्या धड्यात याबद्दल लिहिले आहे , परंतु संकल्पनेचे पुनरावलोकन केल्याने दुखापत होणार नाही. उदाहरणार्थ, आमच्याकडे एक 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. गेटर्स आणि सेटर्स

उदाहरणार्थ, कोणीतरी मांजरीच्या वयाला नकारात्मक क्रमांक देण्याचा प्रयत्न करत आहे की नाही हे पाहण्यासाठी आम्ही तेथे तपासणी करू शकतो. आम्ही आधी म्हटल्याप्रमाणे, एन्कॅप्स्युलेशनबद्दल विविध लेखांच्या लेखकांचा अर्थ कधीकधी डेटा आणि पद्धती एकत्र करणे किंवा त्यांना लपवणे किंवा दोन्ही (एकत्रित करणे आणि लपवणे) असा होतो. Java मध्ये दोन्ही यंत्रणा आहेत (इतर OOP भाषांसाठी हे आवश्यक नाही), त्यामुळे शेवटचा अर्थ सर्वात योग्य आहे. Encapsulation आम्हाला अनेक महत्वाचे फायदे देते:

1. ऑब्जेक्टच्या योग्य स्थितीवर नियंत्रण. याची वरील उदाहरणे होती. सेटर आणि खाजगी सुधारक हे सुनिश्चित करतात की आमच्या प्रोग्राममध्ये मांजरी नसतील ज्यांचे वजन 0 असेल.


2. इंटरफेसद्वारे वापरकर्ता-मित्रत्व. केवळ पद्धती बाहेरच्या जगाला "उघड" ठेवल्या जातात. निकाल मिळविण्यासाठी कॉलिंग पद्धती पुरेशा आहेत — ते कसे कार्य करतात याच्या तपशीलांचा शोध घेण्याची गरज नाही.


3. कोड बदल वापरकर्त्यांना प्रभावित करत नाहीत. आम्ही पद्धतींमध्ये कोणतेही आणि सर्व बदल करतो. याचा या पद्धतीच्या वापरकर्त्यावर परिणाम होत नाही: गॅस पेडल लावण्यासाठी योग्य कोड पूर्वी "auto.gas()" असल्यास, तो तसाच राहील. आम्ही गॅस() पद्धतीमध्ये काहीतरी बदलले आहे ही वस्तुस्थिती वापरकर्त्यासाठी अदृश्य राहते: पूर्वीप्रमाणेच, कॉलरला फक्त इच्छित परिणाम प्राप्त होतो.