వస్తువులు మరియు కన్స్ట్రక్టర్లు

1. ఒక వస్తువును సృష్టించడం

సరే, మేము వస్తువులను రూపొందించడానికి చేరుకున్నాము. మీరు దీన్ని ఇంతకు ముందు ఎదుర్కొన్నారు, కానీ ఇప్పుడు మేము ఈ అంశాన్ని మరింత వివరంగా విశ్లేషిస్తాము. వాస్తవానికి వస్తువులను సృష్టించడం చాలా సులభం.

వస్తువును సృష్టించడానికి, మీరు కొత్త ఆపరేటర్‌ని ఉపయోగించాలి . వస్తువును సృష్టించడం సుమారుగా ఇలా కనిపిస్తుంది:

new Class(arguments)

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

Class name = new Class(arguments)

ఒక కొత్త వేరియబుల్ యొక్క సృష్టి ఎక్కడ ఉంది మరియు సమాన గుర్తుకు కుడి వైపున ఉన్న కోడ్ కొత్త వస్తువు యొక్క సృష్టి, దీని రకం .Class nameClass

ఉదాహరణలు:

Object o = new Object();

Cat pet = new Cat();

Scanner console = new Scanner(System.in)

ప్రోగ్రామర్లు తరచుగా వారి తరగతుల తర్వాత వేరియబుల్స్‌కు పేరు పెడతారు, కానీ చిన్న అక్షరంతో. అనుభవం లేని ప్రోగ్రామర్ కోసం, అటువంటి కోడ్ గందరగోళంగా ఉంటుంది:

BufferedReader bufferedReader = new BufferedReader( reader );

Cat cat = new Cat();

PersonInfo personInfo = new PersonInfo()

ఈ కోడ్‌లో తప్పు ఏమీ లేదు - ఇది అత్యంత సాధారణ కోడ్, దీనిలో ఒక వేరియబుల్ సృష్టించబడుతుంది మరియు అదే రకమైన వస్తువు ద్వారా వెంటనే ప్రారంభించబడుతుంది.

సమాన గుర్తుకు ఎడమ వైపున మనకు వేరియబుల్ సృష్టి ఉంది. కుడి వైపున, ఒక వస్తువు యొక్క సృష్టి. అంతే.

2. కన్స్ట్రక్టర్

ఆబ్జెక్ట్‌ని క్రియేట్ చేస్తున్నప్పుడు కొన్ని ఆర్గ్యుమెంట్‌లు తరచుగా పాస్ అవడాన్ని మీరు బహుశా చూసారు. ఇంకా ఏమిటంటే, కొన్ని వస్తువులకు వాదనలు ఆమోదించబడ్డాయి, కానీ మరికొన్నింటికి కాదు. వాదనలతో కూడిన ఈ మొత్తం యంత్రాంగం ఎలా పని చేస్తుంది?

ఇక్కడ కూడా ప్రతిదీ చాలా సులభం: ప్రతి తరగతికి ఒక ప్రత్యేక పద్ధతి (లేదా పద్ధతులు) ఉంటుంది, ఇది ఒక వస్తువును సృష్టించేటప్పుడు ఆమోదించబడిన వాదనలను నిర్వహించడానికి బాధ్యత వహిస్తుంది. ఈ పద్ధతులను కన్స్ట్రక్టర్లు అంటారు . లేదా మనం కేవలం ఒకదాని గురించి మాట్లాడుతున్నప్పుడు: కన్స్ట్రక్టర్ .

సాధారణ పద్ధతి నుండి కన్స్ట్రక్టర్ పద్ధతిని వేరు చేయడం సులభం. ఈ పద్ధతి రెండు ప్రత్యేక లక్షణాలను కలిగి ఉంది:

• కన్స్ట్రక్టర్ పేరు దాని తరగతి పేరు వలె ఉంటుంది (మరియు పెద్ద అక్షరంతో ప్రారంభమవుతుంది)
• కన్స్ట్రక్టర్‌కు తిరిగి వచ్చే రకం లేదు.

సాధారణంగా, ఇది సాధారణంగా ఇలా కనిపిస్తుంది:

modifiers Class(arguments)
{
   Code
}

ఉదాహరణ:

public class Point
{
   public int x;
   public int y;

   Point(int x, int y)
   {
      this.x = x;
      this.y = y;
   }
}

public class Solution
{
   public static void main(String[] args)
   {
      Point point = new Point(5, 10);
   }
}

కన్స్ట్రక్టర్ ఎలా ఉందో గమనించండి: దీనికి రిటర్న్ రకం లేదు మరియు దాని పేరు తరగతి పేరు వలె ఉంటుంది.

మరియు మరొక విషయం: కన్స్ట్రక్టర్ లోపల కోడ్‌ను పరిశీలించండి. కన్స్ట్రక్టర్ యొక్క పారామితులు తరగతి ఫీల్డ్‌ల వలె ఒకే పేర్లను కలిగి ఉంటాయి: x మరియు y. నవల పారామీటర్ పేర్లను రూపొందించకుండా ఉండటం ప్రామాణిక పద్ధతి. పేర్లు క్లాస్‌లోని ఫీల్డ్‌ల మాదిరిగానే ఉంటాయి. పేరు వైరుధ్యం ఈ కీవర్డ్‌ని ఉపయోగించి పరిష్కరించబడుతుంది.

3. కన్స్ట్రక్టర్‌ని పిలుస్తోంది

కొత్త ఆబ్జెక్ట్‌ని సృష్టించడానికి కొత్త ఆపరేటర్ మరియు "కొత్త క్లాస్ ( ఆర్గ్యుమెంట్స్ )" వంటి ఆదేశాన్ని ఉపయోగించినప్పుడు , రెండు విషయాలు జరుగుతాయి:

• జావా మెషీన్ ఒక వస్తువును సృష్టిస్తుంది, దాని రకం క్లాస్
• జావా మెషీన్ ఆబ్జెక్ట్ యొక్క కన్స్ట్రక్టర్‌ని పిలుస్తుంది మరియు మీ వాదనలలో పాస్ చేస్తుంది

ప్రోగ్రామర్‌గా, మీ తరగతికి ఏ కన్‌స్ట్రక్టర్‌లు ఉండాలి మరియు ఈ కన్‌స్ట్రక్టర్‌లు ఏ పారామీటర్‌లను కలిగి ఉండాలో మీరు నిర్ణయించుకోవాలి.

జంతువుల ఆశ్రయం వద్ద పిల్లులను ట్రాక్ చేయడానికి మీరు ఒక తరగతిని సృష్టించాలని నిర్ణయించుకున్నారని అనుకుందాం. అప్పుడు మీ Catతరగతి ఇలా ఉండవచ్చు:

class Cat
{
   public String name;
   public int age;

   public Cat(String name, int age)
   {
      this.name = name;
      this.age = age;
   }
}

Cat cat = new Cat("Whiskers", 2);

Cat cat = new Cat("Whiskers");

Cat cat = new Cat();

తరగతి Catపేరు మరియు వయస్సు పారామితులతో కేవలం ఒక కన్స్ట్రక్టర్ మాత్రమే ఉంది. ఇతర కన్‌స్ట్రక్టర్‌లు లేనందున, ఆబ్జెక్ట్‌ను సృష్టించేటప్పుడు మీరు పిల్లి పేరు ( name) మరియు వయస్సు ( )ని ఆర్గ్యుమెంట్‌లుగా తప్పనిసరిగా పాస్ చేయాలి. ageఆర్గ్యుమెంట్‌లను కన్స్ట్రక్టర్‌కు పంపడం ఐచ్ఛికం కాదు .

4. బహుళ కన్స్ట్రక్టర్లు

కానీ మీకు అవసరమైతే, మీరు తరగతికి బహుళ కన్స్ట్రక్టర్లను జోడించవచ్చు. కన్స్ట్రక్టర్ల సంఖ్య లేదా వాటి పారామితులపై పరిమితి లేదు. మీరు ఒక వస్తువును సృష్టించినప్పుడు, కంపైలర్ స్వయంచాలకంగా పారామితులకు సరిపోలే కన్స్ట్రక్టర్‌ను ఎంచుకుంటుంది

class Cat
{
   public static final int UNKNOWN = -1;
   public String name;
   public int age;

   public Cat(String name, int age)
   {
      this.name = name;
      this.age = age;
   }
   public Cat(String name)
   {
      this.name = name;
      this.age = UNKNOWN; // Unknown
   }
}

Cat cat = new Cat("Whiskers", 2);

Cat cat = new Cat("Whiskers");

Cat cat = new Cat();

పిల్లి వయస్సు తెలియకపోవచ్చు అనే వాస్తవాన్ని పరిగణనలోకి తీసుకోవాలని మేము నిర్ణయించుకున్నాము. ఈ కేసును నిర్వహించడానికి, మేము UNKNOWNకేవలం ఒక పరామితిని కలిగి ఉన్న కన్స్ట్రక్టర్‌తో పాటు ప్రత్యేక స్థిరాంకాన్ని జోడించాము - పిల్లి పేరు.

మేము ఇప్పటికీ రెండు కన్స్ట్రక్టర్‌లలో రెండు వేరియబుల్‌లను ప్రారంభించామని గమనించండి. మేము తెలియని/తప్పిపోయిన పారామితులను స్థిరాంకంతో భర్తీ చేస్తాము UNKNOWN.

వయస్సు వేరియబుల్‌కు ఎటువంటి విలువ కేటాయించబడకపోతే, అది డిఫాల్ట్ విలువ 0ని కలిగి ఉంటుంది. అన్నింటికంటే, వీధిలో కనిపించే పిల్లి 0 పూర్తి సంవత్సరాలు ఉండవచ్చు. అంటే వయస్సు వేరియబుల్‌లో సున్నా తప్పనిసరిగా "తెలియని వయస్సు" అని అర్ధం కాదు.

5. డిఫాల్ట్ కన్స్ట్రక్టర్

మీరు మీ ఆబ్జెక్ట్‌లు ఎలాంటి పారామీటర్‌లు లేకుండా ఇన్‌స్టాంటియేట్ చేయబడాలని కోరుకుంటే, మీ క్లాస్ నో ఆర్గ్యుమెంట్ కన్‌స్ట్రక్టర్‌ని ప్రకటించాలి.

పారామితులు లేని కన్స్ట్రక్టర్ కోడ్ లేని కన్స్ట్రక్టర్ కానవసరం లేదు. అటువంటి కన్స్ట్రక్టర్ ప్రారంభ విలువలతో వేరియబుల్స్‌ను ప్రారంభించే కోడ్‌ను కలిగి ఉంటుంది:

class Cat
{
   public static final int UNKNOWN = -1;
   public String name;
   public int age;

   public Cat(String name, int age)
   {
      this.name = name;
      this.age = age;
   }

   public Cat()
   {
      this.name = "Nameless";
      this.age = UNKNOWN; // Unknown
   }
}

Cat cat = new Cat("Whiskers", 2);

Cat cat = new Cat();

డిఫాల్ట్ కన్స్ట్రక్టర్

మీరు తెలుసుకోవలసిన మరియు గుర్తుంచుకోవలసిన చాలా ముఖ్యమైన విషయం ఉంది.

మీ క్లాస్ ఒక కన్స్ట్రక్టర్ కాదని ప్రకటించినట్లయితే , కంపైలర్ డిఫాల్ట్ కన్స్ట్రక్టర్‌ను జోడిస్తుంది, ఇది పబ్లిక్ మాడిఫైయర్‌తో ఆర్గ్యుమెంట్ లేని కన్స్ట్రక్టర్.

కానీ మీ తరగతి ఒక కన్‌స్ట్రక్టర్‌ని కూడా ప్రకటిస్తే , డిఫాల్ట్ కన్‌స్ట్రక్టర్ జోడించబడదు మరియు మీకు కావాలంటే మీరే జోడించుకోవాలి.

class Cat
{
   public String name;
   public int age;
}

Cat cat = new Cat();