𝗔𝗯𝘀𝘁𝗿𝗮𝗰𝘁𝗶𝗼𝗻 𝗶𝗻 𝗢𝗢𝗣: 𝗛𝗶𝗱𝗶𝗻𝗴 𝗖𝗼𝗺𝗽𝗹𝗲𝘅𝗶𝘁𝘆
तुम्ही पेडल दाबून आणि स्टेअरिंग फिरवून कार चालवता. तुम्हाला फ्युएल इंजेक्शन (fuel injection) किंवा पिस्टनच्या हालचाली समजून घेण्याची गरज नसते. कार या तपशीलांना तुमच्यापासून लपवून ठेवते. तुम्ही फक्त एका साध्या इंटरफेसचा (interface) वापर करता.
सॉफ्टवेअर देखील याच पद्धतीने काम करते.
ईमेल पाठवण्याचा विचार करा. तुमचा कोड बहुधा असा दिसेल:
emailService.send(email);
हे साधे वाटते. पण पडद्यामागे, सिस्टम अनेक कामे करते:
- पत्ता (address) तपासते.
- SMTP सर्व्हरशी कनेक्ट होते.
- वापरकर्त्याची ओळख पटवते (authenticates).
- मेसेज तयार करते.
- पुन्हा प्रयत्न (retries) हाताळते.
- त्रुटींची नोंद (logs errors) करते.
तुम्हाला या पायऱ्या पाहण्याची गरज नाही. तुम्हाला फक्त ईमेल पाठवला जावा, एवढेच महत्त्वाचे असते.
जर तुम्ही प्रत्येक पायरी उघड (expose) केली, तर तुम्ही समस्या निर्माण करता. कल्पना करा की प्रत्येक डेव्हलपरला मॅन्युअली हे कॉल करावे लागले तर:
connect()authenticate()buildMessage()sendMessage()disconnect()
यामुळे तुमचा कोड नाजूक (fragile) होतो. जर तुम्ही तुमचा ईमेल प्रोव्हायडर बदलला, तर तुम्हाला तुमच्या ॲपमधील प्रत्येक ठिकाणी बदल करावा लागेल. तुमचा कोड अंमलबजावणीशी (implementation) घट्टपणे जोडला (tightly coupled) जातो.
Abstraction यावर उपाय शोधते.
Abstraction एखादी ऑब्जेक्ट काय करते हे दर्शवते. ती ती गोष्ट कशी करते हे लपवते. तुम्ही वापरकर्त्याला फक्त त्यांच्या गरजेच्या गोष्टी दाखवता.
वापरकर्ता एका स्थिर इंटरफेससोबत संवाद साधतो. त्यांना तुमच्या ऑथेंटिकेशन लॉजिक किंवा तुमच्या 'रिट्राय स्ट्रॅटेजी'शी देणेघेणे नसते. ते तपशील लपलेले राहतात.
अनेक लोक Abstraction आणि Encapsulation मध्ये गोंधळतात. त्यातील फरक खालीलप्रमाणे आहे:
Encapsulation विचारते: या ऑब्जेक्टची स्थिती (state) कोण बदलू शकते? ते डेटाचे संरक्षण करते.
Abstraction विचारते: वापरकर्त्याने कोणते तपशील पाहिले पाहिजेत? ते गुंतागुंत लपवते.
उत्तम सिस्टम तयार करण्यासाठी ते एकत्र काम करतात.
पुढे, आपण Inheritance बद्दल चर्चा करू. एकच कोड दोनदा न लिहिता सामायिक वर्तन (shared behavior) कसे हाताळायचे, हे आपण पाहू.