ఎన్కప్సులేషన్

1. పరిచయం

మేము నేటి పాఠాన్ని ఎన్‌క్యాప్సులేషన్‌కు అంకితం చేయాలనుకుంటున్నాము . సాధారణ పరంగా ఇది ఏమిటో మీకు ఇప్పటికే తెలుసు.

ఎన్‌క్యాప్సులేషన్ వల్ల కలిగే ప్రయోజనాలు ఏమిటి? వాటిలో చాలా కొన్ని ఉన్నాయి, కానీ నా అభిప్రాయం ప్రకారం, వాటిలో ప్రధానమైనవి నాలుగు:

2. చెల్లుబాటు అయ్యే అంతర్గత స్థితి

ప్రోగ్రామ్‌లలో, ఒక వస్తువు అనేక ఇతర తరగతులతో పరస్పర చర్య చేసినప్పుడు తరచుగా పరిస్థితులు తలెత్తుతాయి. ఆబ్జెక్ట్‌తో ఈ పరస్పర చర్యలు ఆబ్జెక్ట్‌లోని డేటాను పాడు చేయగలవు, తద్వారా ఆబ్జెక్ట్ ఆశించిన విధంగా పని చేయడం అసాధ్యం.

ఫలితంగా, ఆబ్జెక్ట్ దాని అంతర్గత డేటాలో ఏవైనా మార్పులను ట్రాక్ చేయాలి లేదా ఇంకా మెరుగ్గా మార్పులు చేసుకోవాలి.

కొన్ని వేరియబుల్ ఇతర తరగతుల ద్వారా మార్చబడకూడదనుకుంటే, మేము దానిని ప్రైవేట్‌గా ప్రకటిస్తాము. ఒకసారి మనం అలా చేస్తే, దాని స్వంత తరగతికి చెందిన పద్ధతులు మాత్రమే దాన్ని యాక్సెస్ చేయగలవు. వేరియబుల్స్ చదవడానికి మాత్రమే కావాలంటే, public getterసంబంధిత వేరియబుల్స్ కోసం మనం a జోడించాలి.

ఉదాహరణకు, మన సేకరణలోని మూలకాల సంఖ్యను ప్రతి ఒక్కరూ తెలుసుకోవాలని మనం కోరుకుంటున్నాము, కానీ మా అనుమతి లేకుండా వారు సేకరణను మార్చలేరు. అప్పుడు మేము ఒక private int countవేరియబుల్ మరియు ఒక public getCount()పద్ధతిని ప్రకటిస్తాము.

ఎన్‌క్యాప్సులేషన్ యొక్క సరైన ఉపయోగం మా తరగతి యొక్క అంతర్గత డేటాను ఏ తరగతి నేరుగా యాక్సెస్ చేయలేదని నిర్ధారిస్తుంది , కనుక ఇది మా నియంత్రణకు మించిన మార్పులను నిరోధిస్తుంది. ఈ మార్పులు వేరియబుల్స్ మార్చబడిన అదే తరగతికి చెందిన పద్ధతులను కాల్ చేయడం ద్వారా మాత్రమే సాధ్యమవుతాయి.

ఇతర ప్రోగ్రామర్లు మీకు (మీ తరగతికి) సురక్షితమైన మార్గంలో కాకుండా వారికి అత్యంత అనుకూలమైన రీతిలో మీ తరగతులను ఎల్లప్పుడూ ఉపయోగిస్తారని భావించడం ఉత్తమం. ఈ ప్రవర్తన రెండు బగ్‌లకు మూలం అలాగే వాటిని నిరోధించే ప్రయత్నాలు.

3. పద్దతి వాదనలను ధృవీకరిస్తోంది

కొన్నిసార్లు మేము మా పద్ధతులకు పంపిన వాదనలను ధృవీకరించాలి. ఉదాహరణకు, మేము ఒక వ్యక్తిని సూచించే తరగతిని కలిగి ఉన్నామని చెప్పండి మరియు మీరు పుట్టిన తేదీని సెట్ చేయడానికి అనుమతిస్తుంది. ప్రోగ్రామ్ యొక్క లాజిక్ మరియు మా క్లాస్ యొక్క లాజిక్‌తో అర్ధవంతంగా ఉందని నిర్ధారించుకోవడానికి మేము మొత్తం ఇన్‌పుట్ డేటాను తనిఖీ చేయాలి. ఉదాహరణకు, 13వ నెలలో లేదా ఫిబ్రవరి 30న పుట్టిన తేదీని అనుమతించకుండా చేయడం, మొదలైనవి.

ఎవరైనా తమ పుట్టిన తేదీని ఫిబ్రవరి 30ని ఎందుకు సూచిస్తారు? మొదట, డేటాను నమోదు చేసేటప్పుడు ఇది వినియోగదారు లోపం కావచ్చు. రెండవది, ఒక ప్రోగ్రామ్ క్లాక్ వర్క్ లాగా రన్ అవ్వడానికి ముందు దానిలో చాలా లోపాలు ఉండవచ్చు. ఉదాహరణకు, కింది పరిస్థితి సాధ్యమే.

ఒక ప్రోగ్రామర్ రేపు మరుసటి రోజు పుట్టినరోజు అయిన వ్యక్తులను గుర్తించే ప్రోగ్రామ్‌ను వ్రాస్తాడు. ఉదాహరణకు, ఈరోజు మార్చి 3 అనుకుందాం. ప్రోగ్రామ్ ప్రస్తుత నెలలోని రోజుకు 2 సంఖ్యను జోడించి, మార్చి 5న పుట్టిన ప్రతి ఒక్కరి కోసం వెతుకుతుంది. అంతా కరెక్ట్‌గా ఉన్నట్లు అనిపిస్తుంది.

కానీ మార్చి 30 వచ్చినప్పుడు, ప్రోగ్రామ్ ఎవరినీ కనుగొనదు, ఎందుకంటే క్యాలెండర్‌లో మార్చి 32 లేదు. మేము పద్ధతులకు పంపబడిన డేటాను తనిఖీ చేస్తే ప్రోగ్రామ్‌లో చాలా తక్కువ లోపాలు ఉంటాయి.

మేము దాని కోడ్‌ను అధ్యయనం చేసి విశ్లేషించినప్పుడు గుర్తుందా ArrayList? సున్నా కంటే ఎక్కువ లేదా సమానం మరియు శ్రేణి పొడవు కంటే తక్కువ అని మరియు పద్ధతులు తనిఖీ చేసినట్లుgetsetindex మేము చూశాము . అంతేకాదు, శ్రేణి సరిహద్దుల వెలుపల సూచిక పడిపోతే ఈ పద్ధతులు మినహాయింపును అందిస్తాయి. ఇన్‌పుట్ ధ్రువీకరణకు ఇది ఒక క్లాసిక్ ఉదాహరణ.

4. కోడ్ మార్చేటప్పుడు లోపాలను తగ్గించడం

మనం ఒక పెద్ద ప్రాజెక్ట్‌లో పాలుపంచుకున్నప్పుడు సూపర్ ఉపయోగకరమైన క్లాస్ రాశాము అనుకుందాం. ప్రతి ఒక్కరూ దీన్ని ఎంతగానో ఇష్టపడ్డారు, ఇతర ప్రోగ్రామర్లు తమ కోడ్‌లోని వందల ప్రదేశాలలో దీనిని ఉపయోగించడం ప్రారంభించారు.

తరగతి చాలా ఉపయోగకరంగా ఉంది, మీరు దీనికి కొన్ని మెరుగుదలలు ఇవ్వాలని నిర్ణయించుకున్నారు. కానీ మీరు తరగతి నుండి ఏవైనా పద్ధతులను తీసివేస్తే, డజన్ల కొద్దీ వ్యక్తుల కోడ్ కంపైల్ చేయడం ఆగిపోతుంది. వారు ప్రతిదీ తిరిగి వ్రాయవలసి ఉంటుంది. మరియు మీరు ఎన్ని మార్పులు చేస్తే, మీరు మరిన్ని లోపాలు సృష్టిస్తారు. మీరు చాలా సమావేశాలను విచ్ఛిన్నం చేస్తారు మరియు మీరు అసహ్యించుకుంటారు.

కానీ మేము ప్రైవేట్‌గా ప్రకటించబడిన పద్ధతులను మార్చినప్పుడు, ఈ పద్ధతులను పిలవగలిగే ఇతర తరగతి ఎక్కడా లేదని మాకు తెలుసు. మేము వాటిని తిరిగి వ్రాయవచ్చు, పారామితుల సంఖ్య మరియు వాటి రకాలను మార్చవచ్చు మరియు ఏదైనా ఆధారిత బాహ్య కోడ్ పని చేస్తూనే ఉంటుంది. బాగా, కనీసం అది కంపైల్ చేస్తుంది.

5. మన వస్తువు బాహ్య వస్తువులతో ఎలా సంకర్షణ చెందుతుందో మేము నిర్ణయిస్తాము

మన వస్తువుతో చేయగలిగే కొన్ని చర్యలను మనం పరిమితం చేయవచ్చు. ఉదాహరణకు, ఒక వస్తువును ఒక్కసారి మాత్రమే ఇన్‌స్టాంటియేట్ చేయాలనుకుంటున్నాము. ఇది ప్రాజెక్ట్‌లోని అనేక ప్రదేశాలలో సృష్టించబడినప్పటికీ. మరియు మేము ఎన్‌క్యాప్సులేషన్‌కు ధన్యవాదాలు దీన్ని చేయగలము.

ఎన్‌క్యాప్సులేషన్ అదనపు పరిమితులను జోడించడానికి అనుమతిస్తుంది , వీటిని అదనపు ప్రయోజనాలుగా మార్చవచ్చు . ఉదాహరణకు, తరగతి ఒక మార్పులేనిString వస్తువుగా అమలు చేయబడుతుంది . తరగతి యొక్క ఒక వస్తువు దాని సృష్టి క్షణం నుండి మరణించే క్షణం వరకు మారదు. తరగతి యొక్క అన్ని పద్ధతులు ( , , ...), అవి పిలిచే వస్తువుకు ఎటువంటి మార్పులు చేయకుండా కొత్త స్ట్రింగ్‌ను తిరిగి అందిస్తాయి.StringStringremovesubstring

ఎన్‌క్యాప్సులేషన్ చాలా ఆసక్తికరమైన విషయం.