Home-theater-designers
ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్‌లో, కన్స్ట్రక్టర్ అనేది ఒక వస్తువును సృష్టించడానికి మీరు పిలిచే ఒక ప్రత్యేక ఫంక్షన్. కన్స్ట్రక్టర్లు అనేక ప్రత్యేక లక్షణాలను కలిగి ఉంటారు, అవి పని చేయడానికి వీలు కల్పిస్తాయి.
జావాలో, మీరు దాని తరగతి తర్వాత కన్స్ట్రక్టర్ పేరు పెట్టండి. కన్స్ట్రక్టర్ అనేది ఒక పద్ధతి, ఇది వర్తించే తరగతిలో నిర్వచించబడింది. ప్రత్యామ్నాయ ప్రవర్తనను అందించడానికి జావా నిర్మాతలు ఓవర్‌లోడింగ్‌ని ఉపయోగించవచ్చు. జావాలోని కన్స్ట్రక్టర్లు కోడ్‌ను తిరిగి ఉపయోగించడానికి వారసత్వాన్ని కూడా ఉపయోగించుకోవచ్చు.
అయినా మీకు కన్ స్ట్రక్టర్లు ఎందుకు అవసరం?
ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్‌లో కన్స్ట్రక్టర్లు ప్రధానమైనవి, మరియు జావా దీనికి మినహాయింపు కాదు. ఒక డేటా ప్రాపర్టీ మరియు ఒక మెథడ్‌తో మీరు ప్రాథమిక సర్కిల్ క్లాస్‌ని ఎలా నిర్వచించవచ్చో ఈ ఉదాహరణ చూపుతుంది:
public class Circle {
public double radius;
public double area() { return 3.14159 * radius * radius; }
}అప్పుడు మీరు ఈ తరగతి యొక్క ఒక ఉదాహరణను సృష్టించవచ్చు మరియు దానితో పరస్పర చర్య చేయవచ్చు:
Circle c = new Circle();
c.radius = 2;
System.out.println(c.area()); // 12.56636కానీ ఇది ఉన్నదానికంటే తక్కువ సౌకర్యవంతంగా మరియు దృఢంగా ఉంటుంది. అనధికార ప్రాప్యత నుండి డేటాను కాపాడటం, ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రాక్టీస్ మంచిది:
public class Circle {
private double radius;
public double area() { return 3.14159 * radius * radius; }
public void setRadius(double r) { radius = r; }
}ఇప్పుడు కాలింగ్ కోడ్ ఉపయోగించవచ్చు రేడియస్ పద్ధతి మరియు దాని అమలు వివరాల గురించి ఆందోళన చెందాల్సిన అవసరం లేదు:
యూట్యూబ్ ప్రీమియం కుటుంబం ఎంత
Circle c = new Circle();
c.setRadius(2); మీరు ఒక వస్తువును సృష్టించినప్పుడు దానిని అందించడానికి నిర్మాతలు మరింత మెరుగైన మార్గాన్ని అందిస్తారు. వంటి లక్షణాల ప్రారంభానికి అవి చాలా తరచుగా ఉపయోగించబడతాయి వ్యాసార్థం ఇక్కడ.
సాధారణ కన్స్ట్రక్టర్ల ఉదాహరణలు
అత్యంత ప్రాథమిక కన్స్ట్రక్టర్ వాదనలు లేనిది, అది ఏమీ చేయదు:
public class Circle {
public Circle() {}
}ఇది కూడ చూడు: జావాలో తరగతులను ఎలా సృష్టించాలో తెలుసుకోండి
మీరు కన్స్ట్రక్టర్‌ని నిర్వచించకపోతే, జావా అదే విధంగా ప్రవర్తించే డిఫాల్ట్‌ని అందిస్తుంది.
కొన్ని విషయాలను గమనించండి:
- కన్స్ట్రక్టర్ పేరు తరగతి పేరుకు సరిపోతుంది.
- ఈ కన్స్ట్రక్టర్ దీనిని ఉపయోగిస్తుంది ప్రజా యాక్సెస్ మాడిఫైయర్, కాబట్టి ఏ ఇతర కోడ్ అయినా కాల్ చేయవచ్చు.
- కన్స్ట్రక్టర్ రిటర్న్ రకాన్ని కలిగి ఉండదు. ఇతర పద్ధతుల వలె కాకుండా, నిర్మాతలు విలువను తిరిగి ఇవ్వలేరు.
కన్స్ట్రక్టర్లు సాధారణంగా ఒక రకమైన ప్రారంభాన్ని నిర్వహిస్తారు. పై కోడ్ వ్యాసార్థం విలువను ప్రారంభించదని గమనించండి. ఈ సందర్భంలో, భాష స్వయంచాలకంగా దానిని సున్నాకి సెట్ చేస్తుంది. ఈ తరగతి వినియోగదారు ఉపయోగించాలని ఆశిస్తుంది సెట్ రేడియస్ () . 0 కంటే మరింత ఉపయోగకరమైన డిఫాల్ట్‌ని ఉపయోగించడానికి, మీరు దానిని కన్స్ట్రక్టర్‌లో కేటాయించవచ్చు:
public class Circle {
public Circle() { radius = 1; }
}ఈ క్లాస్‌తో సృష్టించబడిన సర్కిల్‌లు కనీసం ఇప్పుడు అసలు ప్రాంతాన్ని కలిగి ఉంటాయి! కాలర్ ఇప్పటికీ ఉపయోగించవచ్చు సెట్ రేడియస్ () 1 కాకుండా ఇతర వ్యాసార్థాన్ని అందించడానికి. కానీ కన్స్ట్రక్టర్ మరింత స్నేహపూర్వకంగా ఉండవచ్చు:
public class Circle {
public Circle(double r) { radius = r; }
}ఇప్పుడు మీరు పుట్టినప్పటి నుండి ఒక నిర్దిష్ట వ్యాసార్థంతో సర్కిల్‌లను సృష్టించవచ్చు:
నా గూగుల్ డ్రైవ్ ఎవరు చూడగలరు
Circle c = new Circle(2);
System.out.println(c.area()); // 12.56636 నిర్మాణదారులకు ఇది చాలా సాధారణ ఉపయోగం. పారామీటర్ విలువలకు వేరియబుల్స్ ప్రారంభించడానికి మీరు తరచుగా వాటిని ఉపయోగిస్తారు.
కన్స్ట్రక్టర్ ఓవర్‌లోడింగ్
తరగతి నిర్వచనంలో మీరు ఒకటి కంటే ఎక్కువ కన్స్ట్రక్టర్లను పేర్కొనవచ్చు:
public Circle() { radius = 1; }
public Circle(double r) { radius = r; }ఇది కాలింగ్ కోడ్‌కు వస్తువులను ఎలా నిర్మించాలో ఎంపిక చేస్తుంది:
Circle c1 = new Circle(2);
Circle c2 = new Circle();
System.out.println(c1.area() + ', ' + c2.area()); // 12.56636, 3.14159కొంచెం క్లిష్టమైన సర్కిల్‌తో, మీరు మరింత ఆసక్తికరమైన కన్స్ట్రక్టర్లను అన్వేషించవచ్చు. ఈ వెర్షన్ దాని స్థానాన్ని నిల్వ చేస్తుంది:
public class Circle {
public double x, y, radius;
public Circle() { radius = r; }
public Circle(double r) { radius = r; }
public Circle(double x, double y, double r) {
this.x = x; this.y = y; radius = r;
}
public double area() { return 3.14159 * radius * radius; }
}మీరు ఇప్పుడు ఆర్గ్యుమెంట్‌తో పాటు ఎటువంటి ఆర్గ్యుమెంట్‌లు, ఒకే వ్యాసార్థం లేదా x మరియు y కోఆర్డినేట్‌లు లేని సర్కిల్‌ని సృష్టించవచ్చు. ఏదైనా పద్ధతి కోసం జావా మద్దతు ఇచ్చే అదే రకమైన ఓవర్‌లోడింగ్ ఇదే.
కన్స్ట్రక్టర్ గొలుసు
మరొకదాని ఆధారంగా ఒక సర్కిల్‌ను సృష్టించడం ఎలా? ఇది సర్కిల్‌లను సులభంగా కాపీ చేసే సామర్థ్యాన్ని మాకు అందిస్తుంది. కింది బ్లాక్‌ను గమనించండి:
public Circle(Circle c) {
this.x = c.x;
this.y = c.y;
this.radius = c.radius;
}ఇది పని చేస్తుంది, కానీ ఇది కొన్ని కోడ్‌లను అనవసరంగా పునరావృతం చేస్తుంది. సర్కిల్ క్లాస్ ఇప్పటికే వ్యక్తిగత లక్షణాలను నిర్వహించే కన్స్ట్రక్టర్‌ను కలిగి ఉన్నందున, బదులుగా మీరు దాన్ని ఉపయోగించి కాల్ చేయవచ్చు ఈ కీవర్డ్:
public Circle(Circle c) {
this(c.x, c.y, c.radius);
}ఇది కన్స్ట్రక్టర్ గొలుసు యొక్క ఒక రూపం, ఒక కన్స్ట్రక్టర్‌ను మరొకటి నుండి పిలుస్తుంది. ఇది తక్కువ కోడ్‌ని ఉపయోగిస్తుంది మరియు ఆపరేషన్‌ను నకిలీ చేయడం కంటే కేంద్రీకృతం చేయడానికి సహాయపడుతుంది.
పేరెంట్ కన్స్ట్రక్టర్కు కాల్ చేయడం
కన్స్ట్రక్టర్ దాని మాతృ తరగతి యొక్క కన్స్ట్రక్టర్‌ను పిలిచినప్పుడు కన్స్ట్రక్టర్ గొలుసు యొక్క ఇతర రూపం ఏర్పడుతుంది. ఇది స్పష్టంగా లేదా అవ్యక్తంగా ఉండవచ్చు. పేరెంట్ కన్స్ట్రక్టర్కు స్పష్టంగా కాల్ చేయడానికి, దీనిని ఉపయోగించండి సూపర్ కీవర్డ్:
super(x, y);సర్కిల్ యొక్క పేరెంట్‌గా ఒక షేప్ క్లాస్ నటనను ఊహించండి:
public class Shape {
double x, y;
public Shape(double _x, double _y) { x = _x; y = _y; }
}ఇది అన్ని షేప్‌ల కోసం సాధారణ పొజిషనింగ్‌ని నిర్వహిస్తుంది, ఎందుకంటే ఇది వారందరూ పంచుకునే కార్యాచరణ. ఇప్పుడు సర్కిల్ క్లాస్ దాని తల్లితండ్రులకు స్థాన నిర్వహణను అప్పగించగలదు:
public class Circle extends Shape {
double radius;
public Circle(double r) { super(0, 0); radius = r; }
public Circle(double x, double y, double r) {
super(x, y);
radius = r;
}
}సూపర్ క్లాస్ నిర్మాణం చాలా ముఖ్యమైన అంశం జావాలో వారసత్వం . మీరు స్పష్టంగా కాల్ చేయకపోతే భాష డిఫాల్ట్‌గా దాన్ని అమలు చేస్తుంది సూపర్ మీ కన్స్ట్రక్టర్లలో
కన్స్ట్రక్టర్‌లపై యాక్సెస్ మోడిఫైయర్‌లు
నిర్మాతలు వారి సంతకంలో యాక్సెస్ మాడిఫైయర్‌ని చేర్చవచ్చు. ఇతర పద్ధతుల వలె, ఇది ఏ రకమైన కాలర్‌ని కన్స్ట్రక్టర్‌ని యాక్సెస్ చేయగలదో నిర్వచిస్తుంది:
public class Test {
private static Test uniqueInstance = new Test();
private Test() { }
public static Test getInstance() {
return uniqueInstance;
}
}ఇది మరింత క్లిష్టమైన ఉదాహరణ, కాబట్టి దీన్ని అర్థం చేసుకోవడానికి జాగ్రత్త వహించండి:
- తరగతి నైరూప్యమైనది కాదు, కాబట్టి దాని నుండి తక్షణం సాధ్యమవుతుంది.
- కన్స్ట్రక్టర్ ప్రైవేట్ కాబట్టి ఈ క్లాస్ మాత్రమే కొత్త సందర్భాన్ని సృష్టించగలదు.
- స్టాటిక్ ప్రాపర్టీ మరియు పద్ధతి ద్వారా, క్లాస్ కాలర్‌లకు తనకంటూ ఒక ఏకైక ఉదాహరణను బహిర్గతం చేస్తుంది.
వస్తువులను సృష్టించడానికి జావాలో కన్స్ట్రక్టర్లను ఉపయోగించండి
ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్‌కు కన్స్ట్రక్టర్లు చాలా ముఖ్యమైనవి. ఆబ్జెక్ట్‌లను సృష్టించడానికి అవి మిమ్మల్ని అనుమతిస్తాయి, ఇది చాలా అవసరం!
జావాలో, నిర్మాతలు ఇతర పద్ధతుల వలె కనిపిస్తారు మరియు అదే విధంగా పని చేస్తారు. డిఫాల్ట్ కన్స్ట్రక్టర్లు, ఓవర్‌లోడింగ్ మరియు కన్స్ట్రక్టర్ చెయినింగ్ చుట్టూ ఉన్న ప్రత్యేక నియమాలను మీరు గుర్తుంచుకోవాలి. నిర్మాతలు మీకు కొత్తవారైతే, ప్రారంభించేటప్పుడు మీరు నేర్చుకోవలసిన ఇతర ప్రధాన జావా భావనలను మీరు చదవాలనుకోవచ్చు.
షేర్ చేయండి షేర్ చేయండి ట్వీట్ ఇమెయిల్ ప్రారంభించేటప్పుడు మీరు నేర్చుకోవలసిన 10 కోర్ జావా కాన్సెప్ట్లుమీరు GUI వ్రాస్తున్నా, సర్వర్ సైడ్ సాఫ్ట్‌వేర్‌ను అభివృద్ధి చేస్తున్నా లేదా Android ఉపయోగించి మొబైల్ అప్లికేషన్‌ని ఉపయోగిస్తున్నా, జావా నేర్చుకోవడం మీకు బాగా ఉపయోగపడుతుంది. మీరు ప్రారంభించడానికి సహాయపడే కొన్ని ప్రధాన జావా అంశాలు ఇక్కడ ఉన్నాయి.
తదుపరి చదవండి సంబంధిత అంశాలు- ప్రోగ్రామింగ్
- జావా
- కోడింగ్ చిట్కాలు
రెండు దశాబ్దాల పాటు సాఫ్ట్‌వేర్ డెవలపర్‌గా పనిచేసిన బాబీ ఒక టెక్నాలజీ astత్సాహికుడు. అతను గేమింగ్‌పై మక్కువ కలిగి, స్విచ్ ప్లేయర్ మ్యాగజైన్‌లో రివ్యూస్ ఎడిటర్‌గా పని చేస్తున్నాడు మరియు ఆన్‌లైన్ పబ్లిషింగ్ & వెబ్ డెవలప్‌మెంట్ యొక్క అన్ని అంశాలలో మునిగిపోయాడు.
ప్రస్తుతం gpus ఎందుకు ఖరీదైనవిబాబీ జాక్ నుండి మరిన్ని
మా వార్తాలేఖకు సభ్యత్వాన్ని పొందండి
టెక్ చిట్కాలు, సమీక్షలు, ఉచిత ఈబుక్‌లు మరియు ప్రత్యేకమైన డీల్స్ కోసం మా వార్తాలేఖలో చేరండి!
సభ్యత్వం పొందడానికి ఇక్కడ క్లిక్ చేయండి