OOP-இல் Abstraction: சிக்கலான தன்மையை மறைத்தல்
நீங்கள் பெடல்களை அழுத்துவதன் மூலமும், ஸ்டீயரிங் சக்கரத்தைச் சுழற்றுவதன் மூலமும் ஒரு காரை ஓட்டுகிறீர்கள். எரிபொருள் செலுத்துதல் (fuel injection) அல்லது பிஸ்டன் இயக்கம் (piston movement) பற்றி நீங்கள் புரிந்து கொள்ள வேண்டிய அவசியமில்லை. கார் இந்த விவரங்களை உங்களிடமிருந்து மறைத்துவிடுகிறது. நீங்கள் ஒரு எளிய இடைமுகத்தை (interface) மட்டுமே பயன்படுத்துகிறீர்கள்.
மென்பொருளும் இதே வழியில் செயல்படுகிறது.
ஒரு மின்னஞ்சலை (email) அனுப்புவதைப் பற்றி யோசியுங்கள். உங்கள் குறியீடு (code) பெரும்பாலும் இப்படித்தான் இருக்கும்:
emailService.send(email);
இது எளிமையாகத் தோன்றலாம். ஆனால் திரைக்குப் பின்னால், சிஸ்டம் பல பணிகளைச் செய்கிறது:
- முகவரியைச் சரிபார்க்கிறது (Validates the address).
- ஒரு SMTP சர்வருடன் இணைகிறது (Connects to an SMTP server).
- பயனரை அங்கீகரிக்கிறது (Authenticates the user).
- செய்தியை உருவாக்குகிறது (Builds the message).
- மீண்டும் முயற்சிப்பதைக் கையாள்கிறது (Handles retries).
- பிழைகளைப் பதிவு செய்கிறது (Logs errors).
இந்த நிலைகளை நீங்கள் பார்க்க வேண்டிய அவசியமில்லை. மின்னஞ்சல் அனுப்பப்படுகிறது என்பதில் மட்டுமே நீங்கள் கவனம் செலுத்துகிறீர்கள்.
ஒவ்வொரு நிலையையும் நீங்கள் வெளிப்படுத்தினால், நீங்கள் சிக்கல்களை உருவாக்குகிறீர்கள். ஒவ்வொரு டெவலப்பரும் (developer) இவற்றைத் தனித்தனியாக அழைக்க வேண்டியிருந்தால் கற்பனை செய்து பாருங்கள்:
connect()authenticate()buildMessage()sendMessage()disconnect()
இது உங்கள் குறியீட்டை பலவீனமானதாக (fragile) மாற்றுகிறது. நீங்கள் உங்கள் மின்னஞ்சல் வழங்குநரை (email provider) மாற்றினால், உங்கள் செயலியில் உள்ள ஒவ்வொரு இடத்திலும் நீங்கள் மாற்றங்களைச் செய்ய வேண்டும். உங்கள் குறியீடு அதன் செயல்பாட்டு முறையுடன் (implementation) மிக நெருக்கமாகப் பிணைக்கப்பட்டுவிடும் (tightly coupled).
Abstraction இதைத் தீர்க்கிறது.
Abstraction ஒரு ஆப்ஜெக்ட் (object) என்ன செய்கிறது என்பதைக் காட்டுகிறது. அது அதை எப்படிச் செய்கிறது என்பதை மறைக்கிறது. பயனருக்குத் தேவையானதை மட்டுமே நீங்கள் காட்டுகிறீர்கள்.
பயனர் ஒரு நிலையான இடைமுகத்துடன் (stable interface) தொடர்பு கொள்கிறார். உங்கள் அங்கீகார தர்க்கம் (authentication logic) அல்லது உங்கள் மறுமுயற்சி உத்தி (retry strategy) பற்றி அவர்கள் கவலைப்படுவதில்லை. அந்த விவரங்கள் மறைக்கப்பட்டே இருக்கும்.
பலர் Abstraction-ஐ Encapsulation-உடன் குழப்பிக்கொள்கிறார்கள். இதோ வித்தியாசம்:
Encapsulation கேட்கிறது: இந்த ஆப்ஜெக்ட்டின் நிலையை (state) யார் மாற்ற முடியும்? இது தரவைப் பாதுகாக்கிறது.
Abstraction கேட்கிறது: பயனர் எந்த விவரங்களைப் பார்க்க வேண்டும்? இது சிக்கலான தன்மையை மறைக்கிறது.
சிறந்த அமைப்புகளை உருவாக்க இவை இரண்டும் இணைந்து செயல்படுகின்றன.
அடுத்து, நாம் Inheritance பற்றி விவாதிப்போம். ஒரே குறியீட்டைத் திரும்பத் திரும்ப எழுதாமல், பொதுவான செயல்பாடுகளை (shared behavior) எவ்வாறு கையாள்வது என்பதைப் பார்ப்போம்.