OOP मधील Abstraction: गुंतागुंत लपवणे
तुम्ही काही साध्या कृतींद्वारे कार चालवता. तुम्ही गॅस पेडल दाबता. तुम्ही स्टेअरिंग फिरवता. तुम्ही ब्रेक लावता.
इंधन इंजिनमध्ये कसे जाते हे तुम्हाला जाणून घेण्याची गरज नाही. पिस्टन कसे हलतात किंवा गिअर कसे बदलतात हे समजून घेण्याचीही तुम्हाला गरज नाही. कार हे सर्व तपशील तुमच्यापासून लपवून ठेवते. तुम्ही एक जटिल यंत्र नियंत्रित करण्यासाठी एका साध्या इंटरफेसचा (interface) वापर करता.
सॉफ्टवेअर देखील याच पद्धतीने काम करते.
ईमेल पाठवण्याचा विचार करा. तुम्ही एक कमांड कॉल करता: emailService.send().
पडद्यामागे, अनेक गोष्टी घडतात:
- सिस्टम पत्ता (address) तपासते.
- ती SMTP कनेक्शन तयार करते.
- ती प्रोव्हायडरसोबत ऑथेंटिकेट (authenticate) होते.
- ती मेसेज तयार करते.
- जर पहिला प्रयत्न अयशस्वी झाला, तर ती पुन्हा प्रयत्न (retries) हाताळते.
तुम्हाला या पायऱ्या पाहण्याची गरज नाही. तुम्हाला फक्त ईमेल पाठवला जावा, एवढेच महत्त्वाचे असते.
जर तुम्ही abstraction वापरले नाही, तर तुमचा कोड असा दिसेल:
connect()authenticate()buildMessage()sendMessage()disconnect()
प्रत्येक वेळी असे केल्याने समस्या निर्माण होतात. तुमच्या कोडचा प्रत्येक भाग खूप जास्त गोष्टी जाणून घेतो. जर तुम्ही तुमचा ईमेल प्रोव्हायडर बदलला, तर तुम्हाला मेल पाठवणाऱ्या कोडची प्रत्येक ओळ अपडेट करावी लागेल. यामुळे तुमची सिस्टम बदलणे कठीण होते.
Abstraction यावर उपाय शोधते. ते एखादी ऑब्जेक्ट काय करते हे दाखवते, पण ती कशी काम करते हे लपवते.
तुम्ही एक साधा इंटरफेस (interface) समोर आणता. कॉल करणारा (caller) फक्त कामावर लक्ष केंद्रित करतो. अंमलबजावणी (implementation) लपवलेली राहते. यामुळे तुमचा कोड decoupled राहतो आणि तो मेंटेन करणे सोपे जाते.
लोक अनेकदा Abstraction आणि Encapsulation मध्ये गोंधळतात.
Encapsulation विचारते: हा डेटा कोण बदलू शकतो? ते अंतर्गत स्थितीचे (internal state) संरक्षण करते. Abstraction विचारते: वापरकर्त्याला कोणते तपशील पाहण्याची गरज आहे? ते गुंतागुंत लपवते.
उत्तम सिस्टम तयार करण्यासाठी ते एकत्र काम करतात.
पुढे, आपण Inheritance पाहणार आहोत. आपण एका प्रश्नाचे उत्तर शोधू: जर ऑब्जेक्ट्समध्ये समान वर्तन (behavior) असेल, तर तुम्हाला तोच कोड दोनदा लिहिण्याची गरज आहे का?