OOP-இல் Abstraction: Complexity-ஐ மறைத்தல்
நீங்கள் சில எளிய செயல்களின் மூலம் ஒரு காரை ஓட்டுகிறீர்கள். நீங்கள் ஆக்சிலரேட்டரை அழுத்துகிறீர்கள். ஸ்டீயரிங்கைத் திருப்புகிறீர்கள். பிரேக்கை அழுத்துகிறீர்கள்.
எரிபொருள் எவ்வாறு இன்ஜினுக்குள் செல்கிறது என்பதை நீங்கள் தெரிந்து கொள்ள வேண்டிய அவசியமில்லை. பிஸ்டன்கள் (pistons) எவ்வாறு நகர்கின்றன அல்லது கியர்கள் எவ்வாறு மாறுகின்றன என்பதை நீங்கள் புரிந்து கொள்ள வேண்டிய அவசியமில்லை. கார் அந்த விவரங்களை உங்களிடமிருந்து மறைத்துவிடுகிறது. ஒரு சிக்கலான இயந்திரத்தைக் கட்டுப்படுத்த நீங்கள் ஒரு எளிய interface-ஐப் பயன்படுத்துகிறீர்கள்.
மென்பொருளும் இதேபோலவே செயல்படுகிறது.
ஒரு மின்னஞ்சலை (email) அனுப்புவதைப் பற்றி யோசியுங்கள். நீங்கள் ஒரு command அழைக்கிறீர்கள்: emailService.send().
பின்னணியில், பல விஷயங்கள் நடக்கின்றன:
- சிஸ்டம் முகவரியைச் சரிபார்க்கிறது (validates).
- இது ஒரு SMTP இணைப்பை உருவாக்குகிறது.
- இது ஒரு provider-உடன் authenticate செய்கிறது.
- இது செய்தியை உருவாக்குகிறது.
- முதல் முயற்சி தோல்வியடைந்தால், retries-களைக் கையாள்கிறது.
இந்த நிலைகளை நீங்கள் பார்க்க வேண்டிய அவசியமில்லை. மின்னஞ்சல் அனுப்பப்படுகிறது என்பதில் மட்டுமே நீங்கள் கவனம் செலுத்துகிறீர்கள்.
நீங்கள் abstraction-ஐப் பயன்படுத்தவில்லை என்றால், உங்கள் code இப்படி இருக்கும்:
connect()authenticate()buildMessage()sendMessage()disconnect()
ஒவ்வொரு முறையும் இதைச் செய்வது சிக்கல்களை உருவாக்கும். உங்கள் code-இன் ஒவ்வொரு பகுதியும் மிக அதிகமான விவரங்களை அறிந்து வைத்திருக்கும். நீங்கள் உங்கள் email provider-ஐ மாற்றினால், மின்னஞ்சல் அனுப்பும் ஒவ்வொரு வரியையும் நீங்கள் மாற்ற வேண்டியிருக்கும். உங்கள் system-ஐ மாற்றுவது கடினமாகிவிடும்.
Abstraction இதைத் தீர்க்கிறது. ஒரு object என்ன செய்கிறது என்பதைக் காட்டுகிறது, ஆனால் அது எப்படிச் செயல்படுகிறது என்பதை மறைக்கிறது.
நீங்கள் ஒரு எளிய interface-ஐ வெளிப்படுத்துகிறீர்கள். Caller தனது பணியில் மட்டும் கவனம் செலுத்துகிறார். Implementation மறைக்கப்பட்டே இருக்கும். இது உங்கள் code-ஐ decoupled ஆக வைத்திருக்கவும், எளிதாக பராமரிக்கவும் (maintain) உதவுகிறது.
மக்கள் பெரும்பாலும் Abstraction-ஐ Encapsulation-உடன் குழப்பிக்கொள்கிறார்கள்.
Encapsulation கேட்கிறது: இந்தத் தரவை யார் மாற்ற முடியும்? இது internal state-ஐப் பாதுகாக்கிறது. Abstraction கேட்கிறது: பயனர் எந்த விவரங்களைப் பார்க்க வேண்டும்? இது complexity-ஐ மறைக்கிறது.
சிறந்த systems-களை உருவாக்க இவை இரண்டும் இணைந்து செயல்படுகின்றன.
அடுத்து, நாம் Inheritance பற்றிப் பார்ப்போம். ஒரு கேள்வியைத் தீர்க்கப் போகிறோம்: objects ஒரே மாதிரியான behavior-ஐப் பகிர்ந்து கொண்டால், நீங்கள் ஒரே code-ஐத் திரும்பத் திரும்ப எழுதத் தேவையா?