பொருள் உருவாக்கும் போது செயல்களின் வரிசை

வணக்கம்! இன்றைய பாடம் மிகவும்... உம்... பன்முகத்தன்மை கொண்டதாக இருக்கும் :) நாம் பரந்த அளவிலான தலைப்புகளை உள்ளடக்குவோம், ஆனால் அவை அனைத்தும் பொருள் உருவாக்கும் செயல்முறையுடன் தொடர்புடையதாக இருக்கும் . இதை ஆரம்பம் முதல் இறுதி வரை ஆராய்வோம்: கன்ஸ்ட்ரக்டர்கள் எப்படி அழைக்கப்படுகிறார்கள், எப்படி, எந்த வரிசையில் புலங்கள் (நிலையான புலங்கள் உட்பட) துவக்கப்படுகின்றன, முதலியன. கட்டுரையில் விவாதிக்கப்பட்ட சில புள்ளிகளை நாங்கள் முன்பு தொட்டுள்ளோம், எனவே நீங்கள் பார்க்கலாம். அடிப்படை வகுப்பு கட்டமைப்பாளர்களின் பொருள் . முதலில், ஒரு பொருள் எவ்வாறு உருவாக்கப்படுகிறது என்பதை நினைவில் கொள்வோம். டெவலப்பரின் பார்வையில் இந்த செயல்முறை எப்படி இருக்கும் என்பதை நீங்கள் நன்றாக நினைவில் வைத்திருக்கிறீர்கள்: அவர் ஒரு வகுப்பை உருவாக்குகிறார், எழுதுகிறார் 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. கன்ஸ்ட்ரக்டர்கள் அழைக்கப்படுவதற்கு முன் நிலையான மாறிகள் துவக்கப்படும், மேலும் இது பெற்றோர் வகுப்பில் தொடங்குகிறது. இதை சரிபார்க்க முயற்சிப்போம். vehicleCounterவகுப்பில் உள்ள புலத்தை 10 க்கு சமமாக அமைத்து அதை மற்றும் கன்ஸ்ட்ரக்டர்கள் Vehicleஇரண்டிலும் காட்ட முயற்சிக்கிறோம் .VehicleTruck

   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போது இன்னும் துவக்கப்படவில்லை என்பதை உறுதிசெய்ய, கட்டமைப்பாளரின் ஆரம்பத்திலேயே println அறிக்கையை வேண்டுமென்றே வைக்கிறோம் .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அழைக்கப்படுகிறார்.

   இந்த கட்டத்தில் மட்டுமே, எல்லாவற்றிற்கும் மேலாக, நாங்கள் உடனடியாகத் தொடங்கும் வகுப்பின் கட்டமைப்பாளர் அழைக்கப்படுவார்!

   ஆறாவது படியில் மட்டுமே, எங்கள் டிரக்கிற்கு வாதங்களாக நாம் அனுப்பும் மதிப்புகள் புலங்களுக்கு ஒதுக்கப்படும்.

   நீங்கள் பார்க்க முடியும் என, ஒரு டிரக்கை "கட்டமைப்பது", அதாவது பொருள் உருவாக்கும் செயல்முறை எளிதானது அல்ல. ஆனால் நாங்கள் அதை சிறிய பகுதிகளாக உடைத்துவிட்டோம் என்று தெரிகிறது :)

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