वस्तु निर्माण के दौरान क्रियाओं का क्रम

नमस्ते! आज का पाठ काफी... उह... बहुआयामी :) इस अर्थ में होगा कि हम विषयों की एक विस्तृत श्रृंखला को कवर करेंगे, लेकिन वे सभी वस्तु निर्माण प्रक्रिया से संबंधित होंगे । हम शुरू से अंत तक इसका विश्लेषण करेंगे: कंस्ट्रक्टर को कैसे कॉल किया जाता है, कैसे और किस क्रम में फ़ील्ड्स (स्थैतिक फ़ील्ड सहित) इनिशियलाइज़ किए जाते हैं, आदि। हमने पहले लेख में चर्चा किए गए कुछ बिंदुओं को छुआ है, इसलिए आप इस पर नज़र डाल सकते हैं बेस क्लास कंस्ट्रक्टर्स पर सामग्री । सबसे पहले, आइए याद करें कि कोई वस्तु कैसे बनाई जाती है। आपको अच्छी तरह याद है कि डेवलपर के दृष्टिकोण से यह प्रक्रिया कैसी दिखती है: वह एक वर्ग बनाता है, लिखता है new, और सब कुछ तैयार है :) यहां हम इस बारे में बात करेंगे कि जब हम लिखते हैं तो कंप्यूटर और जावा मशीन के अंदर क्या होता है, उदाहरण के लिए:

Cat cat = new Cat();

हमने इसके बारे में पहले भी बात की है, लेकिन शायद हम आपको याद दिला दें:

• सबसे पहले, ऑब्जेक्ट को स्टोर करने के लिए मेमोरी आवंटित की जाती है।
• अगला, जावा मशीन ऑब्जेक्ट के लिए एक संदर्भ बनाता है (हमारे मामले में संदर्भ कैट कैट है)।
• अंत में, वेरिएबल्स को इनिशियलाइज़ किया जाता है और कंस्ट्रक्टर को कॉल किया जाता है (हम इस प्रक्रिया को और अधिक विस्तार से देखने जा रहे हैं)।

इसके अलावा, वस्तु जीवन चक्र के पाठ से , आपको शायद याद होगा कि कोई वस्तु तब तक बनी रहती है जब तक उसमें कम से कम एक संदर्भ होता है। यदि कोई नहीं बचा है, तो वस्तु कचरा संग्राहक का शिकार बन जाती है। इन पहले दो बिंदुओं से कोई विशेष प्रश्न नहीं उठना चाहिए। मेमोरी आवंटन एक सरल प्रक्रिया है, और केवल दो संभावित परिणाम हैं: या तो मेमोरी है या नहीं है :) और लिंक बनाना असामान्य नहीं है। लेकिन तीसरा बिंदु सख्त क्रम में निष्पादित संचालन के पूरे सेट का प्रतिनिधित्व करता है। मैं परीक्षणों के लिए रटने का प्रशंसक नहीं हूं, लेकिन आपको इस प्रक्रिया को अच्छी तरह से समझने की आवश्यकता है और आपको संचालन के इस क्रम को याद करने की आवश्यकता है. जब हमने पिछले पाठों में वस्तु निर्माण प्रक्रिया के बारे में बात की थी, तो आप वास्तव में अभी तक वंशानुक्रम के बारे में कुछ नहीं जानते थे, इसलिए कुछ चीजों को समझाना समस्याजनक था। अब आप काफी कुछ जानते हैं और हम अंत में इस प्रश्न पर पूरी तरह से विचार कर सकते हैं :) तो तीसरा बिंदु कहता है " अंत में, वेरिएबल्स को इनिशियलाइज़ किया जाता है और कंस्ट्रक्टर को कॉल किया जाता है। " लेकिन यह सब किस क्रम में होता है? एक बेहतर समझ के लिए, आइए दो सुपर सरल वर्ग बनाएं - माता-पिता और बच्चे:

public class Vehicle {

   public static int vehicleCounter = 0;

   private String description = "Vehicle";
   public Vehicle() {
   }

   public String getDescription() {
       return description;
   }
}

public class Truck extends Vehicle {

   private static int truckCounter = 0;

   private int yearOfManufacture;
   private String model;
   private int maxSpeed;

   public Truck(int yearOfManufacture, String model, int maxSpeed) {
       this.yearOfManufacture = yearOfManufacture;
       this.model = model;
       this.maxSpeed = maxSpeed;

       Vehicle.vehicleCounter++;
       truckCounter++;
   }
}

वर्ग Truckएक ट्रक का कार्यान्वयन है जिसमें उसके वर्ष, मॉडल और अधिकतम गति का प्रतिनिधित्व करने वाले क्षेत्र हैं। अब हम एक ऐसी वस्तु बनाना चाहते हैं:

public class Main {

   public static void main(String[] args) throws IOException {

       Truck truck = new Truck(2017, "Scania S 500 4x2", 220);
   }
}

जावा मशीन के लिए, प्रक्रिया इस तरह दिखेगी:

1. पहली चीज जो होती है वह यह है कि क्लास के स्टैटिक वेरिएबल्स को Vehicleइनिशियलाइज़ किया जाता है । हां, मैंने Vehicleक्लास कहा, नहीं Truck। कंस्ट्रक्टर को बुलाए जाने से पहले स्टेटिक वैरिएबल को इनिशियलाइज़ किया जाता है, और यह पैरेंट क्लास में शुरू होता है। आइए इसे सत्यापित करने का प्रयास करें। हम फ़ील्ड को 10 के बराबर वर्ग vehicleCounterमें सेट करते हैं और इसे कंस्ट्रक्टर्स दोनों में प्रदर्शित करने का प्रयास करते हैं।VehicleVehicleTruck

   public class Vehicle {
   
      public static int vehicleCounter = 10;
      private String description = "Vehicle";
   
      public Vehicle() {
          System.out.println(vehicleCounter);
      }
   
      public String getDescription() {
          return description;
      }
   }
   
   public class Truck extends Vehicle {
   
      private static int truckCount = 0;
   
      private int yearOfManufacture;
      private String model;
      private int maxSpeed;
   
      public Truck(int yearOfManufacture, String model, int maxSpeed) {
          System.out.println(vehicleCounter);
          this.yearOfManufacture = yearOfManufacture;
          this.model = model;
          this.maxSpeed = maxSpeed;
   
          Vehicle.vehicleCounter++;
          truckCount++;
      }
   }

   हम जान-बूझकर कंस्ट्रक्टर की शुरुआत में प्रिंटलाइन स्टेटमेंट डालते हैं Truckताकि यह सुनिश्चित हो सके कि vehicleCounterप्रदर्शित होने पर ट्रक के फील्ड्स को अभी तक इनिशियलाइज़ नहीं किया गया है।

   और यहाँ परिणाम है:

   10
   10

2. पैरेंट क्लास के स्टैटिक वेरिएबल्स को इनिशियलाइज़ करने के बाद, चाइल्ड क्लास के स्टैटिक वेरिएबल्स को इनिशियलाइज़ किया जाता है। हमारे मामले में, यह वर्ग truckCounterका क्षेत्र है।Truck

   आइए एक और प्रयोग करते हैं जहां हम अन्य क्षेत्रों के प्रारंभ होने से पहले कंस्ट्रक्टर के truckCounterअंदर का मान प्रदर्शित करने का प्रयास करेंगे:Truck

   public class Truck extends Vehicle {
   
      private static int truckCounter = 10;
   
      private int yearOfManufacture;
      private String model;
      private int maxSpeed;
   
      public Truck(int yearOfManufacture, String model, int maxSpeed) {
          System.out.println(truckCounter);
          this.yearOfManufacture = yearOfManufacture;
          this.model = model;
          this.maxSpeed = maxSpeed;
   
          Vehicle.vehicleCounter++;
          truckCounter++;
      }
   }

   जैसा कि आप देख सकते हैं, कंस्ट्रक्टर शुरू होने पर वैल्यू 10 पहले से ही हमारे स्टैटिक वेरिएबल को असाइन किया जा चुका है ।Truck

3. यह अभी भी निर्माणकर्ताओं के लिए समय नहीं है! चर आरंभीकरण जारी है। पैरेंट क्लास के नॉन-स्टैटिक वेरिएबल्स को इनिशियलाइज़ थर्ड किया जाता है। जैसा कि आप देख सकते हैं, वंशानुक्रम एक वस्तु बनाने की प्रक्रिया को काफी जटिल करता है, लेकिन इसके बारे में आप कुछ नहीं कर सकते हैं: आपको प्रोग्रामिंग में कुछ चीजों को याद रखना होगा :)

   एक प्रयोग के रूप में, हम कक्षा descriptionमें चर के लिए कुछ प्रारंभिक मान निर्दिष्ट कर सकते हैं Vehicleऔर फिर इसे कंस्ट्रक्टर में बदल सकते हैं।

   public class Vehicle {
   
      public static int vehicleCounter = 10;
   
      private String description = "Initial value of the description field";
   
      public Vehicle() {
          System.out.println(description);
          description = "Vehicle";
          System.out.println(description);
      }
   
      public String getDescription() {
          return description;
      }
   }

   main()ट्रक बनाने वाली हमारी पद्धति को चलाते हैं :

   public class Main {
   
      public static void main(String[] args) throws IOException {
   
          Truck truck = new Truck(2017, "Scania S 500 4x2", 220);
      }
   }

   हमें निम्नलिखित परिणाम मिलते हैं:

   Initial value of the description field
   Vehicle

   यह साबित करता है कि जब Vehicleकंस्ट्रक्टर शुरू होता है तो descriptionफ़ील्ड को पहले ही एक मान दिया जा चुका होता है।

4. अंत में, यह कंस्ट्रक्टर्स के लिए समय है! अधिक सटीक रूप से, यह बेस क्लास कंस्ट्रक्टर का समय है। इसे वस्तु निर्माण प्रक्रिया के चौथे चरण में लागू किया जाता है।

   इसे सत्यापित करना भी काफी आसान है। आइए कंसोल में दो पंक्तियों को आउटपुट करने का प्रयास करें: एक Vehicleबेस क्लास कंस्ट्रक्टर के अंदर, दूसरा Truckकंस्ट्रक्टर के अंदर। हमें आश्वस्त होना चाहिए कि अंदर की रेखा Vehicleपहले प्रदर्शित होती है:

   public Vehicle() {
   
      System.out.println("Hello from the Vehicle constructor!");
   }
   
   public Truck(int yearOfManufacture, String model, int maxSpeed) {
   
      System.out.println("Hello from the Truck constructor!");
      this.yearOfManufacture = yearOfManufacture;
      this.model = model;
      this.maxSpeed = maxSpeed;
   
      Vehicle.vehicleCounter++;
      truckCounter++;
   }

   हम अपना तरीका चलाएंगे main()और परिणाम देखेंगे:

   Hello from the Vehicle constructor!
   Hello from the Truck constructor!

   उत्कृष्ट। इसका मतलब है कि हम गलत नहीं हैं :) चलिए आगे बढ़ते हैं।

5. अब समय आ गया है कि चाइल्ड क्लास यानी हमारी क्लास के नॉन-स्टैटिक फील्ड्स को इनिशियलाइज़ किया जाए । Truckकक्षा के भीतर तत्काल होने वाले क्षेत्रों को पांचवें चरण तक प्रारंभ नहीं किया जाता है! हैरानी की बात है, लेकिन सच है :) फिर से, हम एक साधारण जांच करेंगे - ठीक पैरेंट क्लास की तरह: हम वेरिएबल के लिए कुछ शुरुआती वैल्यू लेंगे maxSpeedऔर Truckकंस्ट्रक्टर में हम चेक करेंगे कि कंस्ट्रक्टर शुरू होने से पहले वैल्यू असाइन की गई थी:

   public class Truck extends Vehicle {
   
      private static int truckCounter = 10;
   
      private int yearOfManufacture;
      private String model;
      private int maxSpeed = 150;
   
      public Truck(int yearOfManufacture, String model, int maxSpeed) {
   
          System.out.println("Initial value of maxSpeed = " + this.maxSpeed);
          this.yearOfManufacture = yearOfManufacture;
          this.model = model;
          this.maxSpeed = maxSpeed;
   
          Vehicle.vehicleCounter++;
          truckCounter++;
      }
   }

   कंसोल आउटपुट:

   Initial value of maxSpeed = 150

   जैसा कि आप देख सकते हैं,  जब Truck कंस्ट्रक्टर शुरू होता है, maxSpeed तो यह पहले से ही 150 के बराबर होता है!

6. Truckचाइल्ड क्लास के कंस्ट्रक्टर को कहा जाता है।

   और केवल इस बिंदु पर, सबसे अंत में, उस वर्ग के निर्माता को बुलाया जाएगा जिसे हम तत्काल कर रहे हैं!

   केवल छठे चरण में फ़ील्ड्स को वे मान दिए जाएँगे जिन्हें हम अपने ट्रक को तर्क के रूप में पास करते हैं।

   जैसा कि आप देख सकते हैं, एक ट्रक का "निर्माण", यानी वस्तु निर्माण प्रक्रिया, सरल नहीं है। लेकिन ऐसा लगता है कि हमने इसे छोटे-छोटे हिस्सों में तोड़ दिया है :)

इस प्रक्रिया को अच्छी तरह से समझना इतना महत्वपूर्ण क्यों है? कल्पना करें कि एक साधारण वस्तु बनाने के परिणाम कितने अप्रत्याशित हो सकते हैं यदि आपको ठीक से पता नहीं था कि "हुड के नीचे" क्या हो रहा है :) अब यह पाठ्यक्रम पर लौटने और कुछ कार्यों को पूरा करने का समय है! गुड लक और जल्द ही मिलते हैं! :)