కంపోజిషన్ ప్రోగ్రామర్లు ఇప్పటికే ఉన్న తరగతులను కొత్త తరగతుల్లోకి చేర్చడం ద్వారా వాటిని మళ్లీ ఉపయోగించుకోవడానికి అనుమతిస్తుంది. కోడ్ పునర్వినియోగాన్ని మెరుగుపరిచే బహుళ తరగతుల నుండి కోడ్‌ని నకిలీ చేయడానికి బదులుగా. అంతేకాకుండా, ఒక తరగతి యొక్క అందుకున్న అవసరాల ఆధారంగా వస్తువులను కలపడంలో కూర్పు సౌలభ్యాన్ని అందిస్తుంది. ఇది మాడ్యులారిటీని కూడా ప్రోత్సహిస్తుంది మరియు కోడ్‌ను మార్పులకు మరింత అనుకూలంగా మార్చుతుంది.
ఈ వ్యాసం ఉదాహరణల సహాయంతో జావాలో కూర్పు యొక్క వివరణాత్మక వివరణను ప్రదర్శిస్తుంది.
ఉదాహరణలతో జావాలో కూర్పును ఎలా ఉపయోగించాలి?
కంపోజిషన్ తరగతుల మధ్య వదులుగా కలపడాన్ని ప్రోత్సహిస్తుంది. కంపోజ్ చేయబడిన వస్తువులు ఇంటర్‌ఫేస్‌లు, అబ్‌స్ట్రాక్ట్ క్లాస్‌లు లేదా సూపర్ క్లాస్‌ల ద్వారా యాక్సెస్ చేయబడతాయి, ఇవి క్లయింట్ క్లాస్‌ను నిర్దిష్ట ఇంప్లిమెంటేషన్‌ల నుండి వేరు చేస్తాయి. ఇది కోడ్ నిర్వహణ సామర్థ్యాన్ని మెరుగుపరుస్తుంది మరియు సులభంగా పరీక్ష మరియు రీఫ్యాక్టరింగ్‌ను అనుమతిస్తుంది.
జావాలో కంపోజిషన్‌పై మంచి అవగాహన కోసం దిగువ ఉదాహరణను సందర్శించండి:
ఉదాహరణ: జావాలో కంపోజిషన్ కాన్సెప్ట్‌ని అమలు చేయడం
కంపోజిషన్ కాన్సెప్ట్‌ను అమలు చేయడం కోసం ఫంక్షన్‌ను వారసత్వంగా పొందే రెండు లేదా అంతకంటే ఎక్కువ తరగతులను సృష్టించడం మరియు దిగువ చూపిన విధంగా సమయం మరియు కోడ్ సంక్లిష్టతను తగ్గించే పద్ధతులు:
తరగతి ఇంజిన్ {ప్రైవేట్ స్ట్రింగ్ రకం ;
పబ్లిక్ ఇంజిన్ ( స్ట్రింగ్ రకం ) {
this.type = రకం ;
}
పబ్లిక్ శూన్య ప్రారంభం ( ) {
System.out.println ( రకం + 'ఇంజిన్ స్టార్ట్' ) ;
}
పబ్లిక్ శూన్యమైన స్టాప్ ( ) {
System.out.println ( రకం + 'ఇంజిన్ ఆగిపోయింది' ) ;
}
}
తరగతి బైక్ {
ప్రైవేట్ స్ట్రింగ్ వెర్షన్;
ప్రైవేట్ ఇంజిన్ ఇంజిన్;
పబ్లిక్ బైక్ ( స్ట్రింగ్ వెర్షన్, ఇంజిన్ ఇంజిన్ )
{
this.version = వెర్షన్;
this.engn = ఇంజిన్;
}
పబ్లిక్ శూన్యమైన స్టార్ట్‌బైక్ ( ) {
System.out.println ( 'బైక్ స్టార్ట్ చేస్తున్నాను' + వెర్షన్ ) ;
ప్రారంభించండి ( ) ;
}
పబ్లిక్ శూన్యమైన స్టాప్బైక్ ( ) {
System.out.println ( 'బైక్ ఆపడం' + వెర్షన్ ) ;
enng.stop ( ) ;
}
}
పై కోడ్ యొక్క వివరణ:
- ముందుగా, '' పేరుతో తరగతిని సృష్టించండి ఇంజిన్ ” మరియు “ అనే స్ట్రింగ్ టైప్ పారామీటర్‌ని తీసుకువచ్చే డిఫాల్ట్ కన్‌స్ట్రక్టర్‌ను ప్రారంభించండి రకం ”.
- తరువాత, '' అనే రెండు విధులను ప్రకటించండి ప్రారంభం() 'మరియు' ఆపు() ” అది కన్సోల్‌లో నకిలీ సందేశాలను ముద్రిస్తుంది.
- ఆపై, '' పేరుతో కొత్త తరగతిని సృష్టించండి బైక్ ” మరియు డిఫాల్ట్ కన్స్ట్రక్టర్ ఉపయోగించబడుతుంది, ఇందులో వేరియబుల్ మరియు పై క్లాస్ యొక్క ఆబ్జెక్ట్‌ను పారామీటర్‌గా కలిగి ఉంటుంది.
- అలాగే, 'బైక్' తరగతి లోపల సృష్టించబడిన వేరియబుల్స్ మరియు ఆబ్జెక్ట్‌ల కోసం ఈ పారామితులను విలువలుగా సెట్ చేయండి. ఇది విలువలను తరగతి లోపల అందుబాటులో ఉంచుతుంది.
- ఆ తరువాత, '' పేరుతో రెండు విధులు సృష్టించబడతాయి. స్టార్ట్‌బైక్() 'మరియు' స్టాప్ బైక్() ” అని ఒక డమ్మీ మెసేజ్‌ని ప్రింట్ చేస్తుంది.
- చివరికి, 'లో సృష్టించబడిన ఫంక్షన్లను పిలుస్తుంది. ఇంజిన్ 'తరగతి' అనే దాని వస్తువును ఉపయోగించడం ద్వారా engn ”.
ఇప్పుడు, 'ని చొప్పించండి ప్రధాన () ” పైన పేర్కొన్న కోడ్ పని చేయడానికి పద్ధతి:
పబ్లిక్ క్లాస్ కంపోజిషన్ {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
ఇంజిన్ ఎవరూ = కొత్త ఇంజన్ ( 'YBR' ) ;
Bike bik = కొత్త బైక్ ( 'భారీ బైక్' , ఎవరూ ) ;
bik.startBike ( ) ;
bik.stopబైక్ ( ) ;
}
}
పై కోడ్ యొక్క వివరణ:
- మొదట, '' యొక్క వస్తువు ఇంజిన్ 'తరగతి పేరుతో సృష్టించబడింది' ఎవరూ ” మరియు యాదృచ్ఛిక స్ట్రింగ్ రకం విలువ దాని కన్స్ట్రక్టర్‌కు పంపబడుతుంది.
- తరువాత, '' కోసం ఒక వస్తువును సృష్టించండి బైక్ 'తరగతి పేరు' ప్రత్యేకంగా ”. ఆ తర్వాత, 'ఇంజిన్' క్లాస్ ఆబ్జెక్ట్‌తో పాటు స్ట్రింగ్ టైప్ విలువను దాని కన్స్ట్రక్టర్‌కు ఆర్గ్యుమెంట్‌గా పాస్ చేయండి.
- చివరికి, కాల్ చేయండి ' స్టార్ట్‌బైక్() 'మరియు' స్టాప్ బైక్() ''ని ఉపయోగించి విధులు ప్రత్యేకంగా ” వస్తువు.
పై కోడ్ స్నిప్పెట్ అమలు చేసిన తర్వాత:
ఎగువ స్నాప్‌షాట్ కంపోజిషన్ కాన్సెప్ట్‌ని ఉపయోగించి డేటా తిరిగి పొందబడిందని చూపిస్తుంది.
కూర్పు యొక్క నిజ-సమయ వినియోగం
కూర్పు యొక్క భావన కీలక పాత్ర పోషిస్తున్న అనేక నిజ-సమయ అనువర్తనాలు ఉన్నాయి. వీటిలో కొన్ని
ఉపయోగాలు క్రింద వ్రాయబడ్డాయి:
- లో ' GUI అభివృద్ధి ”, కంపోజిషన్ సాధారణంగా సంక్లిష్ట UI భాగాలను రూపొందించడానికి ఉపయోగించబడుతుంది. ఉదాహరణకు, ఒక విండో క్లాస్ బటన్, లేబుల్ మరియు టెక్స్ట్ ఫీల్డ్ వంటి వస్తువులను కంపోజ్ చేయవచ్చు.
- ది ' డిపెండెన్సీ ఇంజెక్షన్ ”స్ప్రింగ్ వంటి ఫ్రేమ్‌వర్క్‌లు, ఆబ్జెక్ట్‌లలోకి డిపెండెన్సీలను ఇంజెక్ట్ చేయడానికి కంపోజిషన్‌ను ఎక్కువగా ఉపయోగించుకుంటాయి.
- కూర్పు విస్తృతంగా ఉపయోగించబడుతుంది ' అప్లికేషన్ డిజైన్ 'సంబంధిత కార్యాచరణలతో బ్యాంక్ ఖాతాను సూచించడానికి కస్టమర్, లావాదేవీ మరియు బ్యాలెన్స్ వంటి వస్తువుల మధ్య సంక్లిష్ట సంబంధాలను మోడల్ చేయడానికి
- కూర్పు ప్రాథమికమైనది ' కాంపోనెంట్ ఆధారిత అభివృద్ధి ”, ఇక్కడ పెద్ద సిస్టమ్‌లను సృష్టించడానికి పునర్వినియోగ భాగాలు కంపోజ్ చేయబడతాయి.
- సరళమైన డేటా నిర్మాణాలను కలిపి మరింత సంక్లిష్టమైన వాటిని రూపొందించడానికి వివిధ డేటా నిర్మాణాలలో కంపోజిషన్ ఉపయోగించబడుతుంది.
ముగింపు
సాధారణ వస్తువులను విలీనం చేయడం ద్వారా సంక్లిష్ట వస్తువులను రూపొందించడానికి కంపోజిషన్ ఉపయోగించబడుతుంది. ఇది '' ఆధారంగా తరగతుల మధ్య సంబంధాలను ఏర్పరచుకోవడానికి ప్రోగ్రామర్‌లను అనుమతిస్తుంది. ఒక ” సంబంధం, దీనిలో మొదటి తరగతి రెండవ తరగతికి సంబంధించిన ఉదాహరణను కలిగి ఉంటుంది. కంపోజిషన్ కాన్సెప్ట్‌ని ఉపయోగించడం ద్వారా, ప్రోగ్రామర్ నిర్దిష్ట ప్రవర్తనలతో వస్తువులను కంపోజ్ చేయడం ద్వారా మాడ్యులర్, పునర్వినియోగం మరియు సౌకర్యవంతమైన డిజైన్‌లను సాధించవచ్చు.