మునుపటి బ్లాగులో, మీరు దాని గురించి తెలుసుకున్నారు జావాలో. ఇప్పుడు ఈ బ్లాగులో, మనకు మరో ముఖ్యమైన స్తంభం అర్థం అవుతుంది అనగా జావా సంగ్రహణ దీని ప్రధాన కార్యాచరణ అంతర్గత అమలు వివరాలను దాచడం.
నేను ఈ వ్యాసంలో క్రింద పేర్కొన్న విషయాలను కవర్ చేస్తాను:
c ++ లో నేమ్‌స్పేస్‌లు ఏమిటి
- OOP లో సంగ్రహణ
- జావా సంగ్రహణ అంటే ఏమిటి?
- వియుక్త తరగతి
- ఇంటర్ఫేస్
- జావాలో సంగ్రహణ యొక్క నిజ జీవిత ఉదాహరణ
- సంగ్రహణ vs ఎన్కప్సులేషన్
మీరు ఈ రికార్డింగ్ ద్వారా కూడా వెళ్ళవచ్చు ఇక్కడ మీరు ఉదాహరణలతో ఉదాహరణలను వివరంగా అర్థం చేసుకోవచ్చు.
OOP లో సంగ్రహణ
మేము సాధారణంగా సంగ్రహణ గురించి మాట్లాడేటప్పుడు సాఫ్ట్‌వేర్ భాష సంగ్రహణకు ఒక ఉదాహరణ. ఒక ఉదాహరణ తీసుకుందాం మరియు ఒక ప్రకటన రాయండి-
x = y + z
పై స్టేట్మెంట్లో, మేము రెండు వేర్వేరు ప్రదేశాలలో నిల్వ చేయబడిన రెండు వేరియబుల్స్ను జోడిస్తున్నాము మరియు ఫలితాన్ని క్రొత్త ప్రదేశంలో నిల్వ చేస్తున్నాము. కాబట్టి, తరువాత ఏమి జరుగుతుంది? మీకు తెలిసినట్లుగా, రిజిస్టర్లు, ఇన్స్ట్రక్షన్ సెట్లు, ప్రోగ్రామ్ కౌంటర్లు, నిల్వ యూనిట్లు మొదలైనవి ఉన్నాయి. మేము జావాలో సంగ్రహణను సూచించినప్పుడు, మేము సంగ్రహణ గురించి మాట్లాడుతున్నాము మరియు అది ఎలా సాధించబడుతుంది. OOP లో సంగ్రహణ భావన ఒక తరగతి గర్భం దాల్చిన తరుణంలోనే మొదలవుతుంది. సాఫ్ట్‌వేర్ మరియు OOP లో ప్రతిచోటా సంగ్రహణ వర్తించబడుతుంది.
జావా సంగ్రహణ అంటే ఏమిటి?
సంగ్రహణ అనేది సంఘటనల కంటే ఆలోచనలతో వ్యవహరించే నాణ్యత తప్ప మరొకటి కాదు. ఇది ప్రాథమికంగా అంతర్గత వివరాలను దాచడం మరియు వినియోగదారుకు అవసరమైన విషయాలను చూపించడం.
మీరు పై gif ని చూస్తే, మీకు కాల్ వచ్చినప్పుడు మీరు చూడవచ్చు, దాన్ని తీయటానికి లేదా తిరస్కరించడానికి మాకు ఒక ఎంపిక వస్తుంది. కానీ వాస్తవానికి, ఈ నేపథ్యంలో నడుస్తున్న కోడ్ చాలా ఉంది. కాబట్టి ఇక్కడ, కాల్ ఎలా ఉత్పత్తి అవుతుందో మీకు అంతర్గత ప్రాసెసింగ్ తెలియదు, అది సంగ్రహణ యొక్క అందం. మీరు రెండు విధాలుగా సంగ్రహణను సాధించవచ్చు:
ఎ) వియుక్త తరగతి
బి) ఇంటర్ఫేస్
ఈ భావనలను మరింత వివరంగా అర్థం చేసుకుందాం.
వియుక్త తరగతి
వియుక్త తరగతిలో ‘నైరూప్య’ కీవర్డ్ ఉంది. కానీ దాని అర్థం ఏమిటి? మీరు తరగతిని నైరూప్యంగా చేస్తే, అది తక్షణం చేయబడదు, అనగా మీరు ఒక నైరూప్య తరగతి యొక్క వస్తువును సృష్టించలేరు. అలాగే, ఒక నైరూప్య తరగతిలో నైరూప్య మరియు కాంక్రీట్ పద్ధతులు ఉంటాయి.
గమనిక: మీరు ఒక నైరూప్య తరగతిని ఉపయోగించి 0-100% సంగ్రహణను సాధించవచ్చు.
నైరూప్య తరగతిని ఉపయోగించడానికి, మీరు దానిని బేస్ క్లాస్ నుండి వారసత్వంగా పొందాలి. ఇక్కడ, మీరు నైరూప్య పద్ధతుల కోసం అమలులను అందించాలి, లేకపోతే అది ఒక నైరూప్య తరగతి అవుతుంది.
నైరూప్య తరగతి యొక్క వాక్యనిర్మాణాన్ని చూద్దాం:
tostring () పద్ధతి జావా
వియుక్త తరగతి క్రీడలు {// నైరూప్య తరగతి క్రీడలు వియుక్త శూన్య జంప్ () // నైరూప్య పద్ధతి}ఇంటర్ఫేస్
జావాలో ఇంటర్ఫేస్ అనేది నైరూప్య పద్ధతులు మరియు స్థిర స్థిరాంకాల సమాహారం. ఇంటర్ఫేస్లో మీకు తెలిసినట్లుగా, ప్రతి పద్ధతి పబ్లిక్ మరియు నైరూప్యంగా ఉంటుంది, కానీ ఇందులో ఏ కన్స్ట్రక్టర్ ఉండదు. సంగ్రహణతో పాటు, జావాలో బహుళ వారసత్వాన్ని సాధించడానికి ఇంటర్ఫేస్ సహాయపడుతుంది.
గమనిక: మీరు ఇంటర్ఫేస్లను ఉపయోగించి 100% సంగ్రహణను సాధించవచ్చు.
సాధారణంగా, ఇంటర్ఫేస్ అనేది ఖాళీ శరీరాలతో సంబంధిత పద్ధతుల సమూహం. ఆకృతి ఇంటర్‌ఫేస్‌కు దాని సంబంధిత పద్ధతులతో ఉదాహరణ తీసుకొని ఇంటర్ఫేస్లను అర్థం చేసుకుందాం.
పబ్లిక్ ఇంటర్ఫేస్ ఆకారం {పబ్లిక్ శూన్య డ్రా () పబ్లిక్ డబుల్ getArea ()}ఈ పద్ధతులు ప్రతి ‘ఆకారంలో’ ఉండాలి, సరియైనదా? కానీ వారి పని భిన్నంగా ఉంటుంది.
మీరు ఆకారాన్ని గీయాలని అనుకుందాం, సర్కిల్, చదరపు, దీర్ఘచతురస్రం మొదలైనవి చెప్పండి. మీకు ఇప్పటికే తెలుసు, ప్రతి ఆకారం వ్యాసార్థం, ఎత్తు మరియు వెడల్పు వంటి దాని స్వంత కొలతలు కలిగి ఉంటుంది. నేను ఒక వృత్తాన్ని గీయాలని మరియు దాని ప్రాంతాన్ని లెక్కించాలనుకుంటున్నాను. అదే పరిగణనలోకి తీసుకుంటే, పై కోడ్‌లో నేను రెండు పద్ధతులను సృష్టించాను, అనగా డ్రా () మరియు getArea (). ఇప్పుడు, ఈ పద్ధతులను ఉపయోగించి, నేను ఏదైనా ఆకారాన్ని గీయవచ్చు మరియు దాని ఇంటర్ఫేస్ను అమలు చేయడం ద్వారా ప్రాంతాన్ని లెక్కించగలను.
జావాలో టోస్ట్రింగ్ ఏమి చేస్తుంది
ఇప్పుడు, మీరు ఈ ఇంటర్ఫేస్ను ఎలా అమలు చేయవచ్చనే దానిపై కార్యాచరణను పరిశీలిద్దాం.
ఈ ఇంటర్ఫేస్ను అమలు చేయడానికి, మీ తరగతి పేరు ఏదైనా ఆకారానికి మారుతుంది, “సర్కిల్” అని చెప్పండి. కాబట్టి, క్లాస్ ఇంటర్ఫేస్ను అమలు చేయడానికి, నేను ‘అమలు’ కీవర్డ్‌ని ఉపయోగించుకుంటాను:
పబ్లిక్ క్లాస్ సర్కిల్ ఆకారం {ప్రైవేట్ డబుల్ వ్యాసార్థం పబ్లిక్ సర్కిల్ (డబుల్ r) {this.radius = r} void draw () {System.out.println ('డ్రాయింగ్ సర్కిల్')} పబ్లిక్ డబుల్ getArea () {తిరిగి Math.PI * this.radius * this.radius} public double getRadius () this this.radius return} పబ్లిక్ క్లాస్ టెస్ట్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ అర్గ్స్ []) {ఆకారం c = కొత్త సర్కిల్ (8) c.draw () సిస్టమ్. out.println ('ప్రాంతం =' + c.getArea ())}} పై ఉదాహరణలో, నేను వివిధ పద్ధతులకు మరియు వృత్తం యొక్క లెక్కించిన ప్రాంతానికి కార్యాచరణలను పేర్కొన్నాను. ఇక్కడ, ఇంటర్ఫేస్ను అమలు చేస్తున్నప్పుడు, అది అందించే ప్రవర్తన గురించి ఒక తరగతి మరింత లాంఛనప్రాయంగా మారడానికి ఇది అనుమతిస్తుంది. మీరు మరొక తరగతిని కూడా సృష్టించవచ్చు, విభిన్న కార్యాచరణలతో ఒకే ఇంటర్ఫేస్ ‘ఆకారాన్ని’ వారసత్వంగా పొందగల ‘దీర్ఘచతురస్రం’ తరగతి చెప్పండి.
జావాలో సంగ్రహణ యొక్క నిజ-సమయ ఉదాహరణ
మనకు ఇంటర్‌ఫేస్‌గా స్పోర్ట్ ఉందని అనుకుందాం. ఇక్కడ, 'బ్యాడ్మింటన్' మరియు 'ఫుట్‌బాల్' అనే తరగతుల ద్వారా అమలు అందించబడుతుంది. నిజమైన దృష్టాంతంలో, తుది వినియోగదారుకు అమలు తరగతి గురించి తెలియదు. అందువల్ల, ఫ్యాక్టరీ పద్ధతి ద్వారా అమలు తరగతి యొక్క వస్తువును అందించవచ్చు. కొన్ని ప్రమాణాల ఆధారంగా అమలు తరగతి యొక్క వస్తువును సృష్టించడానికి ఫ్యాక్టరీ పద్ధతిని ఉపయోగించవచ్చు.
దీనిని అమలు చేసి, స్పోర్ట్.జావా అనే ఇంటర్ఫేస్ను సృష్టించండి.
పబ్లిక్ ఇంటర్ఫేస్ స్పోర్ట్ oid శూన్యమైన ఆట ()} // ఇప్పుడు, మేము 'బ్యాడ్మింటన్' అనే క్లాస్ ను క్రియేట్ చేస్తాము పబ్లిక్ క్లాస్ బ్యాడ్మింటన్ స్పోర్ట్ ను అమలు చేస్తుంది public public పబ్లిక్ శూన్య ఆటను ఓవర్రైడ్ చేయండి () తరువాత మన చివరి తరగతి “ఫుట్‌బాల్” పబ్లిక్ క్లాస్‌ను సృష్టిద్దాం ఫుట్‌బాల్ క్రీడను అమలు చేస్తుంది public public పబ్లిక్ శూన్య ఆటను ఓవర్రైడ్ చేయండి () {System.out.println ('ఫుట్‌బాల్ ఆడటం')} చివరి దశ “స్పోర్ట్ ఇంటర్ఫేస్” అనే ప్రధాన తరగతిని సృష్టించడం.
పబ్లిక్ స్పోర్ట్ ఇంటర్ఫేస్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ అర్గ్స్ []) {// మీ కోడ్ ఇక్కడ}} మీరు పై ప్రోగ్రామ్‌ను అమలు చేసినప్పుడు, అవుట్పుట్ క్రింద చూపిన విధంగా ఉంటుంది:
బ్యాడ్మింటన్ ఆడటం ------------------- ఫుట్‌బాల్ ఆడటం
ఇంటర్‌ఫేస్‌తో మీరు అబ్బాయిలు స్పష్టంగా ఉన్నారని మరియు దాన్ని ఉపయోగించి సంగ్రహణను ఎలా సాధించవచ్చో నేను ఆశిస్తున్నాను. ఇప్పుడు, సంగ్రహణ మరియు ఎన్‌క్యాప్సులేషన్‌ను పోల్చడం ద్వారా ఈ కథనాన్ని ముగించాము.
సంగ్రహణ vs ఎన్కప్సులేషన్
| సంగ్రహణ | ఎన్కప్సులేషన్ |
| డిజైన్ స్థాయిలో సమస్యను పరిష్కరిస్తుంది | అమలు స్థాయిలో సమస్యను పరిష్కరిస్తుంది |
| అవాంఛిత డేటాను దాచడానికి మరియు సంబంధిత ఫలితాలను ఇవ్వడానికి ఉపయోగిస్తారు | ఎన్కప్సులేషన్ అంటే బయటి ప్రపంచం నుండి డేటాను రక్షించడానికి కోడ్ మరియు డేటాను ఒకే యూనిట్లో దాచడం |
| Layer టర్ లేఅవుట్ - డిజైన్ పరంగా ఉపయోగిస్తారు | ఇన్నర్ లేఅవుట్ - అమలు పరంగా ఉపయోగిస్తారు |
సంగ్రహణ మరియు ఎన్‌క్యాప్సులేషన్ మధ్య వ్యత్యాసాన్ని మీరు అర్థం చేసుకున్నారని నేను నమ్ముతున్నాను. దీనితో, మేము జావా సంగ్రహణ బ్లాగులో ముగిశాము. ఆశిస్తున్నాము, మీరు దానిని సమాచారంగా కనుగొన్నారు మరియు ఇది మీ జ్ఞానానికి విలువను జోడించడంలో సహాయపడింది. మీరు జావా గురించి మరింత తెలుసుకోవాలనుకుంటే, మీరు వీటిని చూడవచ్చు
ఇప్పుడు మీరు “జావా సంగ్రహణ అంటే ఏమిటి” అని అర్థం చేసుకున్నారు, చూడండి ప్రపంచవ్యాప్తంగా విస్తరించి ఉన్న 250,000 మందికి పైగా సంతృప్తికరమైన అభ్యాసకుల నెట్‌వర్క్‌తో విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. ఎడురేకా యొక్క జావా J2EE మరియు SOA శిక్షణ మరియు ధృవీకరణ కోర్సు జావా డెవలపర్‌గా ఉండాలనుకునే విద్యార్థులు మరియు నిపుణుల కోసం రూపొందించబడింది. ఈ కోర్సు మీకు జావా ప్రోగ్రామింగ్‌లోకి రావడానికి మరియు హైబర్నేట్ & స్ప్రింగ్ వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌లతో పాటు కోర్ మరియు అడ్వాన్స్‌డ్ జావా కాన్సెప్ట్‌లకు శిక్షణ ఇవ్వడానికి రూపొందించబడింది.
మాకు ప్రశ్న ఉందా? దయచేసి ఈ “జావా సంగ్రహణ” బ్లాగ్ యొక్క వ్యాఖ్యల విభాగంలో పేర్కొనండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.