𝗔𝗯𝘀𝘁𝗿𝗮𝗰𝘁𝗶𝗼𝗻 𝗶𝗻 𝗢𝗢𝗣: 𝗛𝗶𝗱𝗶𝗻𝗴 𝗖𝗼𝗺𝗽𝗹𝗲𝘅𝗶𝘁𝘆
మీరు పెడల్స్ నొక్కడం మరియు స్టీరింగ్ను తిప్పడం ద్వారా కారును నడుపుతారు. మీకు ఫ్యూయల్ ఇంజెక్షన్ లేదా పిస్టన్ కదలికల గురించి అర్థం చేసుకోవాల్సిన అవసరం లేదు. కారు ఈ వివరాలను మీ నుండి దాచి ఉంచుతుంది. మీరు కేవలం ఒక సరళమైన ఇంటర్ఫేస్ను మాత్రమే ఉపయోగిస్తారు.
సాఫ్ట్వేర్ కూడా అదే విధంగా పనిచేస్తుంది.
ఒక ఈమెయిల్ పంపడం గురించి ఆలోచించండి. మీ కోడ్ బహుశా ఇలా ఉంటుంది:
emailService.send(email);
ఇది సరళంగా కనిపిస్తుంది. కానీ తెర వెనుక, సిస్టమ్ అనేక పనులను చేస్తుంది:
- అడ్రస్ను ధృవీకరిస్తుంది.
- SMTP సర్వర్కు కనెక్ట్ అవుతుంది.
- వినియోగదారుని ధృవీకరిస్తుంది.
- మెసేజ్ను సిద్ధం చేస్తుంది.
- మళ్ళీ ప్రయత్నించడాన్ని (retries) హ్యాండిల్ చేస్తుంది.
- లోపాలను (errors) లాగ్ చేస్తుంది.
మీరు ఈ దశలను చూడాల్సిన అవసరం లేదు. ఈమెయిల్ వెళ్తే చాలు, మీకు అది ముఖ్యం.
మీరు ప్రతి దశను బయటపెడితే, సమస్యలు సృష్టిస్తారు. ప్రతి డెవలపర్ మాన్యువల్గా వీటిని పిలవాల్సి వస్తే ఎలా ఉంటుందో ఊహించండి:
connect()authenticate()buildMessage()sendMessage()disconnect()
ఇది మీ కోడ్ను బలహీనంగా (fragile) మారుస్తుంది. మీరు మీ ఈమెయిల్ ప్రొవైడర్ను మార్చితే, మీ యాప్లోని ప్రతి చోటా మార్పులు చేయాల్సి ఉంటుంది. మీ కోడ్ ఇంప్లిమెంటేషన్తో (implementation) విడదీయలేనంతగా ముడిపడిపోతుంది (tightly coupled).
Abstraction దీనిని పరిష్కరిస్తుంది.
Abstraction ఒక ఆబ్జెక్ట్ ఏమి చేస్తుందో తెలియజేస్తుంది. అది ఎలా చేస్తుందో దాచి ఉంచుతుంది. వినియోగదారునికి అవసరమైన దానిని మాత్రమే మీరు చూపిస్తారు.
వినియోగదారుడు ఒక స్థిరమైన ఇంటర్ఫేస్తో సంభాషిస్తారు. మీ అథెంటికేషన్ లాజిక్ లేదా మీ రీట్రై స్ట్రాటజీ గురించి వారు పట్టించుకోరు. ఆ వివరాలు దాగి ఉంటాయి.
చాలా మంది Abstraction మరియు Encapsulation మధ్య అయోమయానికి గురవుతారు. వాటి మధ్య తేడా ఇక్కడ ఉంది:
Encapsulation ఇలా అడుగుతుంది: ఈ ఆబ్జెక్ట్ యొక్క స్థితిని (state) ఎవరు మార్చగలరు? ఇది డేటాను రక్షిస్తుంది.
Abstraction ఇలా అడుగుతుంది: వినియోగదారుడు ఏ వివరాలను చూడాలి? ఇది సంక్లిష్టతను దాచి ఉంచుతుంది.
మెరుగైన సిస్టమ్లను నిర్మించడానికి ఇవి రెండూ కలిసి పనిచేస్తాయి.
తదుపరి, మనం Inheritance గురించి చర్చిస్తాము. ఒకే కోడ్ను రెండుసార్లు రాయకుండా, ఉమ్మడి ప్రవర్తనను (shared behavior) ఎలా నిర్వహించాలో చూద్దాం.