𝗔𝗯𝘀𝘁𝗿𝗮𝗰𝘁𝗶𝗼𝗻 𝗶𝗻 𝗢𝗢𝗣: 𝗛𝗶𝗱𝗶𝗻𝗴 𝗖𝗼𝗺𝗽𝗹𝗲𝘅𝗶𝘁𝘆
ഏതാനും ലളിതമായ പ്രവൃത്തികളിലൂടെയാണ് നിങ്ങൾ ഒരു കാർ ഓടിക്കുന്നത്. നിങ്ങൾ ആക്സിലറേറ്റർ അമർത്തുന്നു. സ്റ്റിയറിംഗ് തിരിക്കുന്നു. ബ്രേക്ക് ഉപയോഗിക്കുന്നു.
ഇന്ധനം എങ്ങനെ എൻജിനിലേക്ക് എത്തുന്നു എന്ന് നിങ്ങൾ അറിയേണ്ടതില്ല. പിസ്റ്റണുകൾ എങ്ങനെ ചലിക്കുന്നുവെന്നോ ഗിയറുകൾ എങ്ങനെ മാറുന്നുവെന്നോ നിങ്ങൾ മനസ്സിലാക്കേണ്ടതില്ല. കാർ ആ വിവരങ്ങൾ നിങ്ങളിൽ നിന്ന് മറച്ചുവെക്കുന്നു. ഒരു സങ്കീർണ്ണമായ യന്ത്രത്തെ നിയന്ത്രിക്കാൻ നിങ്ങൾ ഒരു ലളിതമായ ഇന്റർഫേസ് (interface) ഉപയോഗിക്കുന്നു.
സോഫ്റ്റ്വെയറും ഇതേ രീതിയിലാണ് പ്രവർത്തിക്കുന്നത്.
ഒരു ഇമെയിൽ അയക്കുന്നതിനെക്കുറിച്ച് ചിന്തിക്കുക. നിങ്ങൾ ഒരു കമാൻഡ് വിളിക്കുന്നു: emailService.send().
ഇതിന് പിന്നിൽ പല കാര്യങ്ങളും നടക്കുന്നുണ്ട്:
- സിസ്റ്റം അഡ്രസ് ശരിയാണോ എന്ന് പരിശോധിക്കുന്നു (validates).
- അത് ഒരു SMTP കണക്ഷൻ ഉണ്ടാക്കുന്നു.
- ഒരു പ്രൊവൈഡറുമായി ഓതന്റിക്കേഷൻ (authenticate) നടത്തുന്നു.
- സന്ദേശം തയ്യാറാക്കുന്നു.
- ആദ്യ ശ്രമം പരാജയപ്പെട്ടാൽ വീണ്ടും ശ്രമിക്കുന്നു (retries).
ഈ ഘട്ടങ്ങൾ നിങ്ങൾ കാണേണ്ടതില്ല. ഇമെയിൽ അയക്കപ്പെടുന്നു എന്നത് മാത്രമാണ് നിങ്ങൾ ശ്രദ്ധിക്കുന്നത്.
നിങ്ങൾ Abstraction ഉപയോഗിച്ചില്ലെങ്കിൽ, നിങ്ങളുടെ കോഡ് ഇപ്രകാരമായിരിക്കും:
connect()authenticate()buildMessage()sendMessage()disconnect()
ഓരോ തവണയും ഇത് ചെയ്യുന്നത് പ്രശ്നങ്ങൾ ഉണ്ടാക്കും. നിങ്ങളുടെ കോഡിന്റെ ഓരോ ഭാഗത്തിനും അമിതമായ അറിവ് ലഭിക്കുന്നു. നിങ്ങൾ ഇമെയിൽ പ്രൊവൈഡർ മാറ്റുകയാണെങ്കിൽ, ഇമെയിൽ അയക്കുന്ന കോഡിന്റെ ഓരോ വരിയും നിങ്ങൾ മാറ്റേണ്ടി വരും. ഇത് നിങ്ങളുടെ സിസ്റ്റത്തെ മാറ്റം വരുത്താൻ പ്രയാസമുള്ളതാക്കുന്നു.
Abstraction ഈ പ്രശ്നം പരിഹരിക്കുന്നു. ഒരു ഒബ്ജക്റ്റ് (object) എന്താണ് ചെയ്യുന്നത് എന്ന് ഇത് കാണിച്ചുതരുന്നു, എന്നാൽ അത് എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നത് മറച്ചുവെക്കുന്നു.
നിങ്ങൾ ഒരു ലളിതമായ ഇന്റർഫേസ് പുറത്തുവിടുന്നു. വിളിക്കുന്നയാൾ (caller) അതിന്റെ ലക്ഷ്യത്തിൽ മാത്രം ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു. അതിന്റെ പ്രവർത്തനരീതി (implementation) മറച്ചുവെക്കപ്പെടുന്നു. ഇത് നിങ്ങളുടെ കോഡിനെ പരസ്പരം അമിതമായി ആശ്രയിക്കാത്തതായും (decoupled) പരിപാലിക്കാൻ എളുപ്പമുള്ളതായും നിലനിർത്തുന്നു.
ആളുകൾ പലപ്പോഴും Abstraction-ഉം Encapsulation-ഉം തമ്മിൽ മാറിപ്പോകാറുണ്ട്.
Encapsulation ചോദിക്കുന്നത്: "ആർക്കാണ് ഈ ഡാറ്റ മാറ്റാൻ കഴിയുക?" എന്നാണ്. ഇത് ആന്തരിക അവസ്ഥയെ (internal state) സംരക്ഷിക്കുന്നു. Abstraction ചോദിക്കുന്നത്: "ഉപയോക്താവ് ഏതൊക്കെ വിവരങ്ങളാണ് കാണേണ്ടത്?" എന്നാണ്. ഇത് സങ്കീർണ്ണതകൾ മറച്ചുവെക്കുന്നു.
മികച്ച സിസ്റ്റങ്ങൾ നിർമ്മിക്കാൻ ഇവ രണ്ടും ഒന്നിച്ച് പ്രവർത്തിക്കുന്നു.
അടുത്തതായി, നമ്മൾ Inheritance-നെ കുറിച്ച് പഠിക്കും. ഒരു ചോദ്യത്തിന് നമ്മൾ ഉത്തരം കണ്ടെത്തും: ഒബ്ജക്റ്റുകൾക്ക് ഒരേ സ്വഭാവങ്ങൾ ഉണ്ടെങ്കിൽ, ഒരേ കോഡ് തന്നെ രണ്ടുതവണ എഴുതേണ്ടതുണ്ടോ?