ஜாவா கன்ஸ்ட்ரக்டர்ஸ்

வணக்கம்! இன்று நாம் நமது பொருட்களைப் பற்றிய மிக முக்கியமான தலைப்பைக் கருத்தில் கொள்வோம். மிகைப்படுத்தாமல், இந்த தலைப்பை நீங்கள் ஒவ்வொரு நாளும் நிஜ வாழ்க்கையில் பயன்படுத்துவீர்கள் என்று நாங்கள் கூறலாம்! நாங்கள் ஜாவா கன்ஸ்ட்ரக்டர்களைப் பற்றி பேசுகிறோம். இந்த வார்த்தையை நீங்கள் கேட்பது இதுவே முதல் முறையாக இருக்கலாம், ஆனால் நீங்கள் ஏற்கனவே கன்ஸ்ட்ரக்டர்களைப் பயன்படுத்தியுள்ளீர்கள். நீங்கள் அதை உணரவில்லை :) இதை நாங்கள் பின்னர் நம்புகிறோம்.

உலகில் கட்டமைப்பாளர்கள் என்ன, அவர்கள் ஏன் தேவைப்படுகிறார்கள்?

இரண்டு உதாரணங்களைக் கருத்தில் கொள்வோம்.

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 இல் Amigo Motors Exception என்று அழைக்கப்படுகிறது. ArithmeticException: / by zero இது 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() என்று அழைப்போம் . நீங்கள் ஒரு கார்பேக்டரி பொருளை அதற்கு ஒரு வாதமாக அனுப்பலாம் . நீங்கள் எல்லா தர்க்கங்களையும் அங்கே வைக்கலாம் மற்றும் ஒரே நேரத்தில் சாத்தியமான பிழைகளைக் கையாளலாம் (எங்களுடையது பூஜ்ஜிய ஆண்டுகள் உட்பட). ஒவ்வொருவருக்கும் அவரவர். சரியான பொருள் நிலையை அமைக்க, கட்டமைப்பாளர்கள் தேவை. வணிக தர்க்கத்திற்கான வழிமுறைகள் எங்களிடம் உள்ளன. ஒன்றை மற்றொன்றுடன் கலக்காதீர்கள். நீங்கள் கற்றுக்கொண்டதை வலுப்படுத்த, எங்கள் ஜாவா பாடத்திட்டத்திலிருந்து வீடியோ பாடத்தைப் பார்க்க பரிந்துரைக்கிறோம்