జావా కన్స్ట్రక్టర్స్

హాయ్! ఈ రోజు మనం మన వస్తువులకు సంబంధించిన చాలా ముఖ్యమైన అంశాన్ని పరిశీలిస్తాము. అతిశయోక్తి లేకుండా, మీరు ప్రతిరోజూ ఈ అంశాన్ని నిజ జీవితంలో ఉపయోగిస్తారని మేము చెప్పగలం! మేము జావా కన్స్ట్రక్టర్స్ గురించి మాట్లాడుతున్నాము. మీరు ఈ పదాన్ని వినడం ఇదే మొదటిసారి కావచ్చు, కానీ వాస్తవానికి మీరు ఇప్పటికే కన్‌స్ట్రక్టర్‌లను ఉపయోగించారు. మీరు దానిని గ్రహించలేదు :) మేము దీని గురించి తరువాత ఒప్పిస్తాము.

ప్రపంచంలో కన్స్ట్రక్టర్లు అంటే ఏమిటి మరియు అవి ఎందుకు అవసరం?

రెండు ఉదాహరణలను పరిశీలిద్దాం.

public class Car {

   String model;
   int maxSpeed;

   public static void main(String[] args) {

       Car bugatti = new Car();
       bugatti.model = "Bugatti Veyron";
       bugatti.maxSpeed = 378;

   }
}

మేము మా కారుని సృష్టించాము మరియు దాని మోడల్ మరియు గరిష్ట వేగాన్ని సెట్ చేసాము. కానీ కార్ ఆబ్జెక్ట్‌కు నిజమైన ప్రాజెక్ట్‌లో 2 ఫీల్డ్‌లు ఉండవు. ఉదాహరణకు, ఇది 16 ఫీల్డ్‌లను కలిగి ఉండవచ్చు!

public class Car {

   String model;// model
   int maxSpeed;// maximum speed
   int wheels;// wheel width
   double engineVolume;// engine volume
   String color;// color
   int productionYear;// production year
   String ownerFirstName;// first name of owner
   String ownerLastName;// last name of owner
   long price;// price
   boolean isNew;// flag indicating whether car is new
   int seatsInTheCar;// number of seats in the car
   String cabinMaterial;// interior material
   boolean insurance;// flag indicating whether car is insured
   String manufacturerCountry;// manufacturer country
   int trunkVolume;// size of the trunk
   int accelerationTo100km;// how long it takes to accelerate to 100 km/h (in seconds)


   public static void main(String[] args) {
       Car bugatti = new Car();

       bugatti.color = "blue";
       bugatti.accelerationTo100km = 3;
       bugatti.engineVolume = 6.3;
       bugatti.manufacturerCountry = "Italy";
       bugatti.ownerFirstName = "Amigo";
       bugatti.productionYear = 2016;
       bugatti.insurance = true;
       bugatti.price = 2000000;
       bugatti.isNew = false;
       bugatti.seatsInTheCar = 2;
       bugatti.maxSpeed = 378;
       bugatti.model = "Bugatti Veyron";

   }

}

మేము కొత్త కార్ ఆబ్జెక్ట్‌ని సృష్టించాము . ఒక సమస్య ఉంది: మాకు 16 ఫీల్డ్‌లు ఉన్నాయి, కానీ మేము 12 మాత్రమే ప్రారంభించాము ! ఇప్పుడే కోడ్‌ని చూడండి మరియు మనం మరచిపోయిన ఫీల్డ్‌లను కనుగొనడానికి ప్రయత్నించండి! అంత సులభం కాదు, అవునా? ఈ పరిస్థితిలో, ప్రోగ్రామర్ సులభంగా పొరపాటు చేయవచ్చు మరియు కొంత ఫీల్డ్‌ని ప్రారంభించడంలో విఫలం కావచ్చు. ఫలితంగా, ప్రోగ్రామ్ తప్పుగా ప్రవర్తిస్తుంది:

public class Car {

   String model;// model
   int maxSpeed;// maximum speed
   int wheels;// wheel width
   double engineVolume;// engine volume
   String color;// color
   int productionYear;// production year
   String ownerFirstName;// first name of owner
   String ownerLastName;// last name of owner
   long price;// price
   boolean isNew;// flag indicating whether car is new
   int seatsInTheCar;// number of seats in the car
   String cabinMaterial;// interior material
   boolean insurance;// flag indicating whether car is insured
   String manufacturerCountry;// manufacturer country
   int trunkVolume;// size of the trunk
   int accelerationTo100km;// how long it takes to accelerate to 100 km/h (in seconds)


   public static void main(String[] args) {
       Car bugatti = new Car();

       bugatti.color = "blue";
       bugatti.accelerationTo100km = 3;
       bugatti.engineVolume = 6.3;
       bugatti.manufacturerCountry = "Italy";
       bugatti.ownerFirstName = "Amigo";
       bugatti.productionYear = 2016;
       bugatti.insurance = true;
       bugatti.price = 2000000;
       bugatti.isNew = false;
       bugatti.seatsInTheCar = 2;
       bugatti.maxSpeed = 378;
       bugatti.model = "Bugatti Veyron";

       System.out.println("Model: Bugatti Veyron. Engine volume: " + bugatti.engineVolume + ". Trunk volume: " + bugatti.trunkVolume + ". Cabin material: " + bugatti.cabinMaterial +
       ". Wheel width: " + bugatti.wheels + ". Purchased in 2018 by Mr. " + bugatti.ownerLastName);

   }

}

కన్సోల్ అవుట్‌పుట్: మోడల్: బుగట్టి వేరాన్. ఇంజిన్ వాల్యూమ్: 6.3. ట్రంక్ వాల్యూమ్: 0. క్యాబిన్ మెటీరియల్: శూన్యం. చక్రాల వెడల్పు: 0. 2018లో మిస్టర్ శూన్యం ద్వారా కొనుగోలు చేయబడింది , కారు కోసం $2 మిలియన్లను వదులుకున్న మీ కొనుగోలుదారు, " మిస్టర్ శూన్య " అని పిలవడం ఇష్టం లేదు! కానీ గంభీరంగా, బాటమ్ లైన్ ఏమిటంటే, మా ప్రోగ్రామ్ ఒక వస్తువును తప్పుగా సృష్టించింది: 0 చక్రం వెడల్పు ఉన్న కారు (అంటే చక్రాలు అస్సలు లేవు), తప్పిపోయిన ట్రంక్, తెలియని పదార్థంతో చేసిన క్యాబిన్ మరియు అన్నింటికంటే, నిర్వచించని యజమాని . ప్రోగ్రామ్ నడుస్తున్నప్పుడు అటువంటి పొరపాటు ఎలా "ఆఫ్" అవుతుందో మీరు మాత్రమే ఊహించగలరు! అలాంటి పరిస్థితులను మనం ఎలాగైనా నివారించాలి. మేము మా ప్రోగ్రామ్‌ను పరిమితం చేయాలి: కొత్త కారుని సృష్టించేటప్పుడువస్తువు, మోడల్ మరియు గరిష్ట వేగం వంటి ఫీల్డ్‌లు ఎల్లప్పుడూ పేర్కొనబడాలని మేము కోరుకుంటున్నాము. లేకపోతే, మేము వస్తువు యొక్క సృష్టిని నిరోధించాలనుకుంటున్నాము. కన్స్ట్రక్టర్లు ఈ పనిని సులభంగా నిర్వహిస్తారు. వారు ఒక కారణం కోసం వారి పేరును పొందారు. కన్స్ట్రక్టర్ ఒక రకమైన తరగతి "అస్థిపంజరం"ని సృష్టిస్తాడు, ప్రతి కొత్త వస్తువు తప్పనిసరిగా సరిపోలాలి. సౌలభ్యం కోసం, రెండు ఫీల్డ్‌లతో కూడిన కార్ క్లాస్ యొక్క సరళమైన సంస్కరణకు తిరిగి వెళ్దాం . మా అవసరాలను పరిగణనలోకి తీసుకుంటే, కార్ క్లాస్ యొక్క కన్స్ట్రక్టర్ ఇలా కనిపిస్తుంది:

public Car(String model, int maxSpeed) {
   this.model = model;
   this.maxSpeed = maxSpeed;
}

// And creating an object now looks like this:

public static void main(String[] args) {
   Car bugatti = new Car("Bugatti Veyron", 378);
}

కన్స్ట్రక్టర్ ఎలా ప్రకటించబడుతుందో గమనించండి. ఇది సాధారణ పద్ధతిని పోలి ఉంటుంది, కానీ దీనికి రిటర్న్ రకం లేదు. అంతేకాకుండా, కన్స్ట్రక్టర్ పెద్ద అక్షరంతో ప్రారంభమయ్యే తరగతి పేరు ( కార్ )ని నిర్దేశిస్తుంది. అదనంగా, కన్స్ట్రక్టర్ మీ కోసం కొత్త కీవర్డ్‌తో ఉపయోగించబడుతుంది: ఇది . నిర్దిష్ట వస్తువును సూచించడానికి ఇది కీలకపదం . కన్స్ట్రక్టర్‌లోని కోడ్

public Car(String model, int maxSpeed) {
   this.model = model;
   this.maxSpeed = maxSpeed;
}

దాదాపు యథాతథంగా అర్థం చేసుకోవచ్చు: " ఈ కారు మోడల్ (మేము ఇప్పుడు సృష్టిస్తున్నది) అనేది కన్స్ట్రక్టర్‌కు పంపబడిన మోడల్ ఆర్గ్యుమెంట్. ఈ కారుకు (మేము సృష్టిస్తున్నది) మాక్స్‌స్పీడ్ ఆర్గ్యుమెంట్ కన్స్ట్రక్టర్." మరియు అదే జరుగుతుంది:

public class Car {

   String model;
   int maxSpeed;

   public Car(String model, int maxSpeed) {
       this.model = model;
       this.maxSpeed = maxSpeed;
   }

   public static void main(String[] args) {
       Car bugatti = new Car("Bugatti Veyron", 378);
       System.out.println(bugatti.model);
       System.out.println(bugatti.maxSpeed);
   }

}

కన్సోల్ అవుట్‌పుట్: బుగట్టి వేరాన్ 378 కన్స్ట్రక్టర్ అవసరమైన విలువలను సరిగ్గా కేటాయించింది. కన్స్ట్రక్టర్ సాధారణ పద్ధతిని పోలి ఉంటుందని మీరు గమనించి ఉండవచ్చు! కాబట్టి ఇది. కన్స్ట్రక్టర్ అనేది నిజంగా ఒక పద్ధతి, కానీ నిర్దిష్ట లక్షణాలతో :) పద్ధతుల మాదిరిగానే, మేము మా కన్స్ట్రక్టర్‌కు వాదనలను పంపాము. మరియు ఒక పద్ధతికి కాల్ చేసినట్లే, కన్స్ట్రక్టర్‌ను కాల్ చేయడం మీరు వాటిని పేర్కొనకపోతే పని చేయదు:

public class Car {

   String model;
   int maxSpeed;

   public Car(String model, int maxSpeed) {
       this.model = model;
       this.maxSpeed = maxSpeed;
   }

   public static void main(String[] args) {
       Car bugatti = new Car(); // Error!
   }
  
}

మేము సాధించడానికి ప్రయత్నిస్తున్న దాన్ని కన్స్ట్రక్టర్ సాధించినట్లు మీరు చూడవచ్చు. ఇప్పుడు మీరు వేగం లేదా మోడల్ లేకుండా కారుని సృష్టించలేరు! కన్స్ట్రక్టర్లు మరియు పద్ధతుల మధ్య సారూప్యత ఇక్కడితో ముగియదు. పద్ధతుల మాదిరిగానే, కన్స్ట్రక్టర్లను ఓవర్‌లోడ్ చేయవచ్చు. మీ ఇంట్లో 2 పెంపుడు పిల్లులు ఉన్నాయని ఊహించుకోండి. మీరు వాటిలో ఒక పిల్లి పిల్లగా పొందారు. కానీ మీరు వీధి నుండి తీసుకున్న రెండవది అది ఇప్పటికే పెరిగినప్పుడు, మరియు అది ఎంత పాతదో మీకు ఖచ్చితంగా తెలియదు. ఈ సందర్భంలో, మా ప్రోగ్రామ్ రెండు రకాల పిల్లులను సృష్టించగలగాలని మేము కోరుకుంటున్నాము: పేరు మరియు వయస్సు ఉన్నవి (మొదటి పిల్లికి), మరియు పేరు మాత్రమే ఉన్నవి (రెండవ పిల్లికి). దీని కోసం, మేము కన్స్ట్రక్టర్‌ను ఓవర్‌లోడ్ చేస్తాము:

public class Cat {

   String name;
   int age;

   // For the first cat
   public Cat(String name, int age) {
       this.name = name;
       this.age = age;
   }

   // For the second cat
   public Cat(String name) {
       this.name = name;
   }

   public static void main(String[] args) {

       Cat smudge = new Cat("Smudge", 5);
       Cat streetCatNamedBob = new Cat("Bob");
   }

}

"పేరు" మరియు "వయస్సు" పారామీటర్‌లతో అసలైన కన్‌స్ట్రక్టర్‌తో పాటు, మేము పేరు పరామితితో మరొకటి జోడించాము. సరిగ్గా అదే విధంగా మేము మునుపటి పాఠాలలో పద్ధతులను ఓవర్‌లోడ్ చేసాము. ఇప్పుడు మనం రెండు రకాల పిల్లులను సృష్టించవచ్చు :) మీకు తెలియకుండానే మీరు ఇప్పటికే కన్‌స్ట్రక్టర్‌లను ఉపయోగించారని మేము పాఠం ప్రారంభంలో చెప్పినట్లు గుర్తుందా? మేము చెప్పినదానిని మేము అర్థం చేసుకున్నాము. వాస్తవం ఏమిటంటే జావాలోని ప్రతి తరగతికి డిఫాల్ట్ కన్స్ట్రక్టర్ అని పిలుస్తారు. దీనికి ఎటువంటి వాదనలు అవసరం లేదు, కానీ మీరు ఏదైనా తరగతికి చెందిన ఏదైనా వస్తువును సృష్టించిన ప్రతిసారీ ఇది అమలు చేయబడుతుంది.

public class Cat {

   public static void main(String[] args) {

       Cat smudge = new Cat(); // The default constructor is invoked here
   }
}

మొదటి చూపులో, ఇది కనిపించదు. మేము ఒక వస్తువును సృష్టించాము, కాబట్టి ఏమిటి? ఇక్కడ కన్స్ట్రక్టర్ ఎక్కడ ఏదైనా చేస్తున్నాడు? దీన్ని చూడటానికి, క్యాట్ క్లాస్ కోసం ఖాళీ కన్‌స్ట్రక్టర్‌ని స్పష్టంగా వ్రాస్దాం . మేము దాని లోపల కొన్ని పదబంధాన్ని ప్రదర్శిస్తాము. పదబంధం ప్రదర్శించబడితే, అప్పుడు కన్స్ట్రక్టర్ ప్రారంభించబడుతుంది.

public class Cat {

   public Cat() {
       System.out.println("A cat has been created!");
   }

   public static void main(String[] args) {

       Cat smudge = new Cat(); // The default constructor is invoked here
   }
}

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

public class Cat {

   String name;
   int age;

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

   public static void main(String[] args) {

       Cat smudge = new Cat(); //Error!
   }
}

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

public class Cat {

   String name;
   int age;

   // For cats with owners
   public Cat(String name, int age) {
       this.name = name;
       this.age = age;
   }

   // For street cats
   public Cat() {
   }

   public static void main(String[] args) {

       Cat smudge = new Cat("Smudge", 5);
       Cat streetCat = new Cat();
   }
}

ఇప్పుడు మేము స్పష్టమైన డిఫాల్ట్ కన్‌స్ట్రక్టర్‌ని వ్రాసాము, మేము రెండు రకాల పిల్లులను సృష్టించగలము :) ఏదైనా పద్ధతి వలె, కన్స్ట్రక్టర్‌కు పంపబడిన వాదనల క్రమం చాలా ముఖ్యమైనది. మన కన్స్ట్రక్టర్‌లో పేరు మరియు వయస్సు ఆర్గ్యుమెంట్‌లను మార్చుకుందాం .

public class Cat {

   String name;
   int age;

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

   public static void main(String[] args) {

       Cat smudge = new Cat("Smudge", 10); // Error!
   }
}

ఒక లోపం! క్యాట్ ఆబ్జెక్ట్‌ను సృష్టించినప్పుడు, ఈ క్రమంలో దానికి ఒక సంఖ్య మరియు స్ట్రింగ్‌ను తప్పనిసరిగా పాస్ చేయాలని కన్స్ట్రక్టర్ స్పష్టంగా నిర్దేశించారు . కాబట్టి, మా కోడ్ పని చేయదు. మీ స్వంత తరగతులను ప్రకటించేటప్పుడు దీన్ని గుర్తుంచుకోండి మరియు గుర్తుంచుకోండి:

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

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

ఇవి పూర్తిగా భిన్నమైన రెండు కన్స్ట్రక్టర్లు! "నాకు కన్స్ట్రక్టర్ ఎందుకు అవసరం?" అనే ప్రశ్నకు మనం ఒకే వాక్యంలో సమాధానం చెప్పాలంటే, "వస్తువులు ఎల్లప్పుడూ చెల్లుబాటు అయ్యే స్థితిని కలిగి ఉండేలా చేయడానికి" అని చెప్పవచ్చు. మీరు కన్స్ట్రక్టర్లను ఉపయోగించినప్పుడు, మీ అన్ని వేరియబుల్స్ సరిగ్గా ప్రారంభించబడతాయి. మీ ప్రోగ్రామ్‌లలో 0 వేగంతో కార్లు లేదా ఇతర "చెల్లని" వస్తువులు ఉండవు. వారి ప్రధాన ప్రయోజనం ప్రోగ్రామర్ కోసం. మీరు ఫీల్డ్‌లను మాన్యువల్‌గా ప్రారంభించినట్లయితే (ఆబ్జెక్ట్‌ని సృష్టించిన తర్వాత), మీరు ఏదైనా కోల్పోయి, బగ్‌ని ప్రవేశపెట్టే ప్రమాదం చాలా ఎక్కువ. కానీ ఇది కన్స్ట్రక్టర్‌తో జరగదు: మీరు అవసరమైన అన్ని ఆర్గ్యుమెంట్‌లను పాస్ చేయడంలో విఫలమైతే లేదా మీరు తప్పుడు రకాల ఆర్గ్యుమెంట్‌లను పాస్ చేసినట్లయితే, కంపైలర్ వెంటనే లోపాన్ని నమోదు చేస్తుంది. మీరు మీ ప్రోగ్రామ్ పెట్టకూడదని మేము కూడా విడిగా చెప్పాలి' కన్స్ట్రక్టర్ లోపల తర్కం. దీని కోసం పద్ధతులు ఉన్నాయి. మీరు అవసరమైన అన్ని కార్యాచరణలను నిర్వచించాల్సిన మెథడ్స్. కన్స్ట్రక్టర్‌కు లాజిక్‌ని జోడించడం ఎందుకు చెడ్డ ఆలోచన అని చూద్దాం:

public class CarFactory {

   String name;
   int age;
   int carsCount;

   public CarFactory(String name, int age, int carsCount) {
   this.name = name;
   this.age = age;
   this.carsCount = carsCount;

   System.out.println("Our car factory is called " + this.name);
   System.out.println("It was founded " + this.age + " years ago" );
   System.out.println("Since that time, it has produced " + this.carsCount +  " cars");
   System.out.println("On average, it produces " + (this.carsCount/this.age) + " cars per year");
}

   public static void main(String[] args) {

       CarFactory ford = new CarFactory("Ford", 115 , 50000000);
   }
}

మేము కార్ ఫ్యాక్టరీని వివరించే కార్ఫ్యాక్టరీ తరగతిని కలిగి ఉన్నాము. కన్స్ట్రక్టర్ లోపల, మేము అన్ని ఫీల్డ్‌లను ప్రారంభించాము మరియు కొంత లాజిక్‌ను చేర్చుతాము: మేము ఫ్యాక్టరీ గురించి కొంత సమాచారాన్ని ప్రదర్శిస్తాము. దీని గురించి చెడు ఏమీ లేదని అనిపిస్తుంది. కార్యక్రమం బాగా పనిచేస్తుంది. కన్సోల్ అవుట్‌పుట్: మా కార్ ఫ్యాక్టరీని ఫోర్డ్ అని పిలుస్తారు, ఇది 115 సంవత్సరాల క్రితం స్థాపించబడింది, అప్పటి నుండి, ఇది 50000000 కార్లను ఉత్పత్తి చేసింది, ఇది సంవత్సరానికి సగటున 434782 కార్లను ఉత్పత్తి చేస్తుంది, అయితే మేము వాస్తవానికి సమయం ఆలస్యమైన గనిని ఏర్పాటు చేసాము. మరియు ఈ విధమైన కోడ్ చాలా సులభంగా లోపాలకు దారి తీస్తుంది. ఇప్పుడు మనం మాట్లాడుతున్నది ఫోర్డ్ గురించి కాదు, "అమిగో మోటార్స్" అనే కొత్త ఫ్యాక్టరీ గురించి, ఇది ఒక సంవత్సరం కంటే తక్కువ కాలం పాటు ఉనికిలో ఉంది మరియు 1000 కార్లను ఉత్పత్తి చేసింది:

public class CarFactory {

   String name;
   int age;
   int carsCount;

   public CarFactory(String name, int age, int carsCount) {
   this.name = name;
   this.age = age;
   this.carsCount = carsCount;

   System.out.println("Our car factor is called " + this.name);
   System.out.println("It was founded " + this.age + " years ago" );
   System.out.println("Since that time, it has produced " + this.carsCount +  " cars");
   System.out.println("On average, it produces " + (this.carsCount/this.age) + " cars per year");
}


   public static void main(String[] args) {

       CarFactory ford = new CarFactory("Amigo Motors", 0 , 1000);
   }
}

కన్సోల్ అవుట్‌పుట్: మా కార్ ఫ్యాక్టరీని థ్రెడ్ "మెయిన్" java.langలో అమిగో మోటార్స్ మినహాయింపు అని పిలుస్తారు. ArithmeticException: / జీరో ద్వారా ఇది 0 సంవత్సరాల క్రితం స్థాపించబడింది, ఆ సమయం నుండి, ఇది కార్‌ఫ్యాక్టరీలో 1000 కార్లను ఉత్పత్తి చేసింది. (CarFactory.java:15) CarFactory.main (CarFactory.java:23) వద్ద నిష్క్రమణ కోడ్ 1తో ప్రక్రియ పూర్తయింది బూమ్! ప్రోగ్రామ్ ఒక రకమైన అపారమయిన లోపంతో ముగుస్తుంది. మీరు కారణాన్ని అంచనా వేయడానికి ప్రయత్నించగలరా? సమస్య మనం కన్స్ట్రక్టర్‌లో ఉంచిన లాజిక్‌లో ఉంది. మరింత ప్రత్యేకంగా, ఈ లైన్:

System.out.println("On average, it produces " + (this.carsCount/this.age) + " cars per year");

ఇక్కడ మీరు గణనను నిర్వహిస్తున్నారు మరియు ఫ్యాక్టరీ వయస్సుతో ఉత్పత్తి చేయబడిన కార్ల సంఖ్యను విభజించారు. మరియు మా ఫ్యాక్టరీ కొత్తది (అంటే ఇది 0 సంవత్సరాల పాతది), మేము గణితంలో చేయలేని 0తో భాగిస్తాము. ఫలితంగా, ప్రోగ్రామ్ లోపంతో ముగుస్తుంది.

మనం ఏం చేసి వుండాలి?

అన్ని లాజిక్‌లను ప్రత్యేక పద్ధతిలో ఉంచండి. దీనిని printFactoryInfo() అని పిలుద్దాం . మీరు దానికి కార్ఫ్యాక్టరీ వస్తువును వాదనగా పంపవచ్చు . మీరు అన్ని లాజిక్‌లను అక్కడ ఉంచవచ్చు మరియు సంభావ్య లోపాలను ఏకకాలంలో నిర్వహించవచ్చు (మాది సున్నా సంవత్సరాలకు సంబంధించినది). ప్రతి ఒక్కరికి తన సొంతం. చెల్లుబాటు అయ్యే వస్తువు స్థితిని సెట్ చేయడానికి కన్స్ట్రక్టర్లు అవసరం. వ్యాపార తర్కం కోసం మాకు పద్ధతులు ఉన్నాయి. ఒకదానితో ఒకటి కలపవద్దు. మీరు నేర్చుకున్న వాటిని బలోపేతం చేయడానికి, మా జావా కోర్సు నుండి వీడియో పాఠాన్ని చూడమని మేము మీకు సూచిస్తున్నాము