మీరు తెలుసుకోవలసిన ప్రతిదీ జావాలో సంబంధాన్ని కలిగి ఉంది

లో సంబంధం ఉంది మరియు ఈజ్ ఎ రిలేషన్షిప్ చాలా గందరగోళ పదాలు. ఈ వ్యాసంలో, మేము ఈ క్రింది పారామితులపై దృష్టి పెడతాము:

హాష్ పట్టిక మరియు హాష్ మ్యాప్ మధ్య వ్యత్యాసం

• జావాలో సంబంధాన్ని కలిగి ఉండటానికి ఒక పరిచయం
• అసోసియేషన్
• సంబంధం: కూర్పు మరియు వారసత్వం

జావాలో సంబంధాన్ని కలిగి ఉండటానికి ఒక పరిచయం

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

కూర్పు అనేది అసోసియేషన్ యొక్క ఒక రూపం. అసోసియేషన్ వారి వస్తువుల ద్వారా అధికారం పొందిన రెండు వేర్వేరు తరగతుల మధ్య సంబంధం అంటారు. అసోసియేషన్ రూపంలో ఉంటుంది:

1. ముఖాముఖి

   
   
   

2. ఒకటి నుండి చాలా వరకు

3. చాలా నుండి ఒకటి

4. చాలా నుండి చాలా వరకు

   
   
   

OOP (ఆబ్జెక్ట్ ఓరియెంటెడ్ ప్రోగ్రామింగ్) లో, ఆబ్జెక్ట్ అన్ని సేవలను మరియు ఆ వస్తువు అందించిన కార్యాచరణలను ఉపయోగించడానికి మరొక వస్తువుతో కమ్యూనికేట్ చేస్తుంది.

అసోసియేషన్

అసోసియేషన్ అమలుకు ఇక్కడ ఒక ఉదాహరణ.

దిగుమతి java.io. * క్లాస్ బ్యాంక్ {ప్రైవేట్ స్ట్రింగ్ నేమ్ బ్యాంక్ (స్ట్రింగ్ పేరు) {this.name = name} పబ్లిక్ స్ట్రింగ్ getBankName () this దీన్ని తిరిగి ఇవ్వండి. name} క్లాస్ ఎంప్లాయీ {ప్రైవేట్ స్ట్రింగ్ పేరు ఉద్యోగి (స్ట్రింగ్ పేరు) {ఇది. పేరు = పేరు} పబ్లిక్ స్ట్రింగ్ getEmployeeName () this దీన్ని తిరిగి ఇవ్వండి}} అసోసియేషన్ అసోసియేషన్ {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {బ్యాంక్ బి = కొత్త బ్యాంక్ ('యాక్సిస్') ఉద్యోగి ఇ = కొత్త ఉద్యోగి ('హిమాన్షి') System.out.println (e.getEmployeeName () + 'అనేది' + b.getBankName ()) యొక్క ఉద్యోగి}}

అవుట్పుట్:

ఇది అసోసియేషన్ యొక్క ప్రత్యేక రూపం:

1. ఇది హస్-ఎ-సంబంధాన్ని సూచిస్తుంది.

2. దీనిని ఏకదిశాత్మక సంఘం (వన్-వే రిలేషన్) అని పిలుస్తారు, ఉదాహరణకు, విభాగంలో ఉపాధ్యాయులు ఉండవచ్చు, కానీ దీనికి విరుద్ధంగా నిజం కాదు మరియు అందువల్ల, ప్రకృతిలో ఏకదిశాత్మక.

ఇప్పుడు కంపోజిషన్ గురించి మాట్లాడుకుందాం

కూర్పు అనేది పరిమితం చేయబడిన రూపం, దీనిలో రెండు వస్తువులు ఒకదానిపై ఒకటి ఎక్కువగా ఆధారపడి ఉంటాయి. రెండు ఎంటిటీల మధ్య కూర్పు ఉన్నప్పుడు, కంపోజ్ మరొక ఎంటిటీ లేకుండా అబద్ధం చెప్పలేము.

కూర్పు యొక్క భావనను చూపించడానికి లైబ్రరీ యొక్క ఉదాహరణ ఇక్కడ ఉంది

దిగుమతి java.io. * దిగుమతి java.util. * క్లాస్ బుక్ {పబ్లిక్ స్ట్రింగ్ టైటిల్ పబ్లిక్ స్ట్రింగ్ రచయిత బుక్ (స్ట్రింగ్ టైటిల్, స్ట్రింగ్ రచయిత) {this.title = title this.author = author}} క్లాస్ లైబ్రరీ {ప్రైవేట్ ఫైనల్ లిస్ట్ బుక్స్ లైబ్రరీ (జాబితా పుస్తకాలు) {this.books = పుస్తకాలు} పబ్లిక్ జాబితా getTotalBooksInLibrary () {రిటర్న్ బుక్స్}} క్లాస్ ఎడురెకా {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {బుక్ బి 2 = కొత్త బుక్ ('థింకింగ్ జావా', 'బ్రూవా ఇ' ) పుస్తకం b3 = క్రొత్త పుస్తకం ('జావా: పూర్తి సూచన', 'హెర్బ్ ఎస్') జాబితా పుస్తకాలు = క్రొత్త శ్రేణి జాబితా () books.add (b2) books.add (b3) లైబ్రరీ లైబ్రరీ = కొత్త లైబ్రరీ (పుస్తకాలు) జాబితా bks = లైబ్రరీ .getTotalBooksInLibrary () (బుక్ bk: bks) {System.out.println ('శీర్షిక:' + bk.title + 'మరియు' + 'రచయిత:' + bk.author)}}}

అవుట్పుట్:

OOPS యొక్క ప్రధాన ప్రయోజనాల్లో ఒకటి మనం కోడ్‌ను తిరిగి ఉపయోగించుకోవచ్చు. మేము కోడ్‌ను తిరిగి ఉపయోగించుకునే రెండు మార్గాలు ఉన్నాయివారసత్వం లేదా వస్తువు కూర్పు ద్వారా.

జావాలో స్కానర్ ఎలా ఉపయోగించాలి

కూర్పు మరియు వారసత్వాన్ని పోల్చడం: సంబంధం

• వారసత్వం కంటే తరగతిని మార్చడం కూర్పులో సులభం.

• కూర్పు డైనమిక్ బైండింగ్ అయితే వారసత్వం స్టాటిక్ బైండింగ్.

• క్లాస్ వారసత్వం కంపైల్ సమయంలో నిర్వచించబడుతుంది, అయితే ఆబ్జెక్ట్ కూర్పు రన్-టైమ్‌లో నిర్వచించబడుతుంది.

• ఆబ్జెక్ట్ కంపోజిషన్‌లో, అంతర్గత వివరాలు ఒకదానికొకటి బహిర్గతం చేయకూడదు మరియు అవి వారి పబ్లిక్ ఇంటర్‌ఫేస్‌ల ద్వారా సంకర్షణ చెందుతాయి, అయితే, వారసత్వంగా, ఇది ప్రజలను మరియు బేస్ క్లాస్ యొక్క రక్షిత సభ్యులను బహిర్గతం చేస్తుంది.

• కూర్పులో, ప్రాప్యతను పరిమితం చేయవచ్చు, ఆబ్జెక్ట్ కూర్పులో, యాక్సెస్ నియంత్రణ లేదు.

• వారసత్వంలో, ఇది దాని తల్లిదండ్రుల అమలు వివరాలకు ఉపవర్గాన్ని బహిర్గతం చేయడం ద్వారా ఎన్‌క్యాప్సులేషన్‌ను విచ్ఛిన్నం చేస్తుంది, అయితే, ఆబ్జెక్ట్ కంపోజిషన్‌లో, ఇది ఎన్‌క్యాప్సులేషన్‌ను విచ్ఛిన్నం చేయదు ఎందుకంటే వస్తువులు వాటి ఇంటర్‌ఫేస్‌ల ద్వారా పూర్తిగా ప్రాప్తి చేయబడతాయి.

• వారసత్వంలో, ఇది కోడ్ పునర్వినియోగతను అందిస్తుంది, అయితే ఆబ్జెక్ట్ కంపోజిషన్‌లో, ఇది సంఘాలను సూచించడానికి అనుమతిస్తుంది.

ఉదాహరణ 1:

ఫైల్ క్లాస్ యొక్క ఉదాహరణను సృష్టించడానికి కారణాలు ఏమిటి?

తరగతి ఆపరేషన్ {int చదరపు (int n) {తిరిగి n * n}} క్లాస్ సర్కిల్ {ఆపరేషన్ op // అగ్రిగేషన్ డబుల్ పై = 3.14 డబుల్ ఏరియా (Int వ్యాసార్థం) {op = new Operation () int rsquare = op.square (radius) // కోడ్ పునర్వినియోగం (అనగా పద్ధతి కాల్‌ను అప్పగిస్తుంది). రిటర్న్ pi * rsquare} పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ అర్గ్స్ []) {సర్కిల్ c = కొత్త సర్కిల్ () డబుల్ ఫలితం = c.area (5) System.out.println (ఫలితం)}}

అవుట్పుట్:

ఉదాహరణ 2:

క్లాస్ హౌస్ {కిచెన్ కె = కొత్త కిచెన్ () // హౌస్ క్లాస్ కోసం మరిన్ని కోడ్} క్లాస్ కిచెన్ {// కిచెన్ క్లాస్ కోడ్}

ఇల్లు నాశనమైతే, వంటగది కూడా నాశనమవుతుంది. రెండు ఎంటిటీలు ఒకదానిపై ఒకటి ఆధారపడి ఉన్నప్పుడు దీనిని కూర్పు అంటారు. కంటైనర్ క్లాస్ (హౌస్) లేకుండా రిఫరెన్స్ క్లాస్ (కిచెన్) ఉనికిలో లేదు.

దీనితో, మేము జావా వ్యాసంలో ఈ సంబంధాన్ని కలిగి ఉన్నాము. ప్రాథమికంగా, కూర్పులో, తరగతి తిరిగి ఉపయోగించాలనుకునే తరగతి వస్తువుకు సూచనను సృష్టించడం ద్వారా తరగతి యొక్క కార్యాచరణను తిరిగి ఉపయోగించుకోవచ్చు. ఇది అగ్రిగేషన్ యొక్క ప్రత్యేక సందర్భం అంటారు.

సి హెక్ అవుట్ ప్రపంచవ్యాప్తంగా 250,000 కంటే ఎక్కువ సంతృప్తికరమైన అభ్యాసకుల నెట్‌వర్క్‌తో విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. ఎడురేకా యొక్క జావా J2EE మరియు SOA శిక్షణ మరియు ధృవీకరణ కోర్సు జావా డెవలపర్‌గా ఉండాలనుకునే విద్యార్థులు మరియు నిపుణుల కోసం రూపొందించబడింది.

మాకు ప్రశ్న ఉందా? దయచేసి ఈ “జావాలో సంబంధం ఉంది” బ్లాగ్ యొక్క వ్యాఖ్యల విభాగంలో పేర్కొనండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.