జావాలో, క్లాస్ యొక్క ఉదాహరణను ప్రారంభించడంలో కన్స్ట్రక్టర్లు కీలక పాత్ర పోషిస్తారు. ఇవి జావా పద్ధతులను పోలి ఉంటాయి. అయినప్పటికీ, కన్స్ట్రక్టర్ పేరు ఎల్లప్పుడూ తరగతి పేరు వలె ఉంటుంది, అయితే సాధారణ పద్ధతి ఏదైనా చెల్లుబాటు అయ్యే పేరును కలిగి ఉంటుంది. ఎక్కువగా, వీటిని ఒక వస్తువును ప్రకటించడానికి ప్రత్యేక పద్ధతులుగా కూడా సూచిస్తారు. మీరు వారసత్వం సహాయంతో సంభవించే కన్స్ట్రక్టర్ చైనింగ్‌ను సృష్టించవచ్చు. చైల్డ్/సబ్‌క్లాస్ కన్స్ట్రక్టర్ మొదట పేరెంట్/సూపర్‌క్లాస్ కన్స్ట్రక్టర్ని పిలుస్తాడు మరియు ఆ తర్వాత, చైల్డ్-క్లాస్ కన్స్ట్రక్టర్లను ఇన్వాక్ చేయవచ్చు.
ఈ పోస్ట్ జావాలో కన్స్ట్రక్టర్ చైనింగ్ గురించి తెలియజేస్తుంది.
జావాలో కన్స్ట్రక్టర్ చైనింగ్
పేర్కొన్న లక్ష్యాల ప్రకారం కన్స్ట్రక్టర్ను మరొక కన్స్ట్రక్టర్‌లోకి పిలవడానికి కన్స్ట్రక్టర్ మారడం అనేది అత్యంత ముఖ్యమైన ప్రక్రియ. కన్స్ట్రక్టర్ చైనింగ్ యొక్క ప్రాథమిక ఉపయోగాలలో ఒకటి బహుళ కన్స్ట్రక్టర్లను కలిగి ఉన్నప్పుడు అనవసరమైన కోడ్‌లను నివారించడం. ఇది కోడ్‌ను సులభంగా అర్థమయ్యేలా మరియు చదవగలిగేలా చేస్తుంది.
క్రింద పేర్కొన్న విధంగా జావాలో కన్స్ట్రక్టర్ చైనింగ్ చేయడానికి రెండు పద్ధతులు ఉన్నాయి:
కన్స్ట్రక్టర్ చైనింగ్ గురించి బాగా అర్థం చేసుకోవడానికి ఈ పద్ధతులను ఒక్కొక్కటిగా చూద్దాం.
విధానం 1: “ఈ()” కీవర్డ్‌ని ఉపయోగించి ఒకే తరగతిలో కన్స్ట్రక్టర్ చైనింగ్
కన్స్ట్రక్టర్ చైనింగ్ ఒకే తరగతిలో ప్రదర్శించబడినప్పుడు, జావా ' ఇది() ” కీవర్డ్ ఉపయోగించబడుతుంది. క్లాస్ ఇన్‌స్టాన్స్ ప్రారంభించబడినప్పుడు డిఫాల్ట్ కన్స్ట్రక్టర్ ప్రారంభించబడుతుంది. ఇది 'ని ఉపయోగించి మరొక కన్స్ట్రక్టర్ని పిలుస్తుంది ఇది ” కీవర్డ్. ఆపై, కన్సోల్‌లో ఫలితాన్ని ప్రదర్శించడానికి “println()” పద్ధతిని అమలు చేయండి:
నిమి ( ) {
ఇది ( 5 ) ;
System.out.println ( 'డిఫాల్ట్ కన్స్ట్రక్టర్' ) ;
}
ఇప్పుడు, పారామీటర్‌తో కూడిన రెండవ కన్స్ట్రక్టర్ని కాల్ చేయండి ' a ” మరియు “లో పారామితుల విలువను సెట్ చేయండి ఇది() ” కీవర్డ్. అప్పుడు, 'ని ఉపయోగించండి println() ” మరియు ఫలితాన్ని చూపించడానికి “a”ని ఆర్గ్యుమెంట్‌గా పాస్ చేయండి:
ఇది ( 5 , ఇరవై ) ;
System.out.println ( a ) ;
}
ఈ కన్స్ట్రక్టర్‌లో, మేము రెండు పూర్ణాంకాల రకం పారామితులను '' a 'మరియు' బి ”. ఆ తర్వాత, “println()” పద్ధతిని అమలు చేసి, “ పాస్ చేయండి a *b ” ఇది ఈ వేరియబుల్స్ యొక్క ఉత్పత్తిని అందిస్తుంది:
System.out.println ( a * బి ) ;
}
లో ' ప్రధాన () ” పద్ధతి, ఇతర కన్స్ట్రక్టర్లను స్వయంచాలకంగా పిలిచి, కన్సోల్‌లో ఫలితాన్ని ప్రదర్శించే డిఫాల్ట్ కన్స్ట్రక్టర్ను ప్రారంభించండి:
కొత్త నిమి ( ) ;
}
ఫలితంగా, అన్ని కన్‌స్ట్రక్టర్‌ల అవుట్‌పుట్ కన్సోల్‌లో ప్రదర్శించబడుతుంది:
మీరు కన్స్ట్రక్టర్ను బహుళ తరగతుల్లో చైన్ చేయాలనుకుంటే, దిగువ పేర్కొన్న పద్ధతిని చూడండి.
విధానం 2: “సూపర్()” కీవర్డ్ ఉపయోగించి కన్స్ట్రక్టర్ చైనింగ్ మరొక తరగతి
మీరు కన్స్ట్రక్టర్లను ఒక తరగతి నుండి మరొక తరగతికి చైన్ చేయవచ్చు. దీని కోసం, “సూపర్ ()” కీవర్డ్ ఉపయోగించబడుతుంది. అలా చేయడానికి, ప్రధాన తరగతిలో క్రింది కోడ్‌ని ఉపయోగించండి.
అన్నింటిలో మొదటిది, స్ట్రింగ్ టైప్ వేరియబుల్‌ను నిర్వచించండి ' పేరు ” మరియు ప్రధాన తరగతి పేరును ఉపయోగించి మొదటి కన్స్ట్రక్టర్‌కు కాల్ చేయండి:
స్ట్రింగ్ పేరు;నిమి ( ) {
ఇది ( '' ) ;
System.out.println ( 'బేస్ క్లాస్ యొక్క కన్స్ట్రక్టర్ లేకుండా' ) ;
}
రెండవ కన్స్ట్రక్టర్ని పిలవండి మరియు పైన పేర్కొన్న వేరియబుల్‌ను పాస్ చేయండి ' స్ట్రింగ్ పేరు ” పారామీటర్ గా. ఉపయోగించడానికి ' ఇది విలువను యాక్సెస్ చేయడానికి మరియు 'ని పిలవడానికి కీవర్డ్' println() 'ముద్రణ ప్రయోజనాల కోసం పద్ధతి:
ఈ.పేరు = పేరు;
System.out.println ( 'కాలింగ్ పారామిటరైజ్డ్ కన్స్ట్రక్టర్ ఆఫ్ బేస్' ) ;
}
లోపల ' ప్రధాన () ”పద్ధతి, చైల్డ్ క్లాస్‌ని పారామీటర్‌తో కాల్ చేయండి” పేరు ”. అది పేరెంట్ క్లాస్ కన్స్ట్రక్టర్లను పిలుస్తుంది ఇక్కడ పరామితి ' పేరు ” పాస్ అయింది. అప్పుడు, ఇది చైల్డ్ క్లాస్ కన్స్ట్రక్టర్ను పారామీటర్‌తో పిలుస్తుంది. పేరు ”:
కొత్త బిడ్డ ( 'పేరు' ) ;
}
'ని ఉపయోగించే పిల్లల తరగతి సృష్టించబడింది విస్తరించింది పేరెంట్ క్లాస్‌ను వారసత్వంగా పొందేందుకు మరియు మూడవ కన్స్ట్రక్టర్ను ఇన్వోక్ చేయడానికి కీవర్డ్. ఆ తర్వాత తదుపరి కన్స్ట్రక్టర్‌కి కాల్ చేసి, ఈ కన్స్ట్రక్టర్ లోపల, పేరెంట్ క్లాస్ సెకండ్ కన్స్ట్రక్టర్ని పిలవండి:
పిల్లవాడు ( ) {
System.out.println ( 'వితౌట్ ఆర్గ్యుమెంట్ కన్స్ట్రక్టర్ ఆఫ్ చైల్డ్ క్లాస్' ) ;
}
పిల్లవాడు ( స్ట్రింగ్ పేరు ) {
సూపర్ ( పేరు ) ;
System.out.println ( 'పిల్లల పారామిటరైజ్డ్ కన్స్ట్రక్టర్ని పిలుస్తోంది' ) ;
}
}
అవుట్‌పుట్
జావాలో కన్స్ట్రక్టర్ చైనింగ్ గురించి అంతే.
ముగింపు
జావాలో, అదే తరగతిలోని కన్స్ట్రక్టర్ చైనింగ్ “దిస్()” కీవర్డ్‌ని ఉపయోగించి చేయబడుతుంది, అయితే “సూపర్()” కీవర్డ్ వివిధ తరగతులపై కన్స్ట్రక్టర్ చైనింగ్‌ను నిర్వహించడానికి ఉపయోగించబడుతుంది. కన్స్ట్రక్టర్ చైనింగ్ వారసత్వం సహాయంతో జరుగుతుంది. సబ్-క్లాస్ కన్స్ట్రక్టర్ మొదట సూపర్-క్లాస్ కన్స్ట్రక్టర్ని పిలుస్తాడు మరియు తర్వాత, చైల్డ్-క్లాస్ కన్స్ట్రక్టర్లను పిలవవచ్చు. ఈ పోస్ట్ జావాలోని కన్స్ట్రక్టర్ చైనింగ్ గురించి ఆచరణాత్మక ఉదాహరణలతో చర్చించబడింది.