వస్తువు సృష్టి సమయంలో చర్యల క్రమం

హాయ్! ఈరోజు పాఠం చాలా... ఉహ్... బహుముఖంగా ఉంటుంది :) మేము విస్తృత శ్రేణి అంశాలను కవర్ చేస్తాము, కానీ అవన్నీ వస్తువు సృష్టి ప్రక్రియకు సంబంధించినవి . మేము దీన్ని మొదటి నుండి చివరి వరకు విశ్లేషిస్తాము: కన్‌స్ట్రక్టర్‌లను ఎలా పిలుస్తారు, ఫీల్డ్‌లు (స్టాటిక్ ఫీల్డ్‌లతో సహా) ఎలా మరియు ఏ క్రమంలో ప్రారంభించబడ్డాయి, మొదలైనవి. మేము గతంలో వ్యాసంలో చర్చించిన కొన్ని పాయింట్‌లను తాకాము, కాబట్టి మీరు పరిశీలించవచ్చు బేస్ క్లాస్ కన్స్ట్రక్టర్లపై ఉన్న పదార్థం . మొదట, ఒక వస్తువు ఎలా సృష్టించబడిందో గుర్తుచేసుకుందాం. డెవలపర్ దృక్కోణం నుండి ఈ ప్రక్రియ ఎలా కనిపిస్తుందో మీకు బాగా గుర్తుంది: అతను ఒక తరగతిని సృష్టిస్తాడు, వ్రాస్తాడు 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ట్రక్కు ఫీల్డ్‌లు ఇంకా ప్రారంభించబడలేదని నిర్ధారించుకోవడానికి మేము ఉద్దేశపూర్వకంగా ప్రింట్‌ఎల్‌ఎన్ స్టేట్‌మెంట్‌ను కన్స్ట్రక్టర్ ప్రారంభంలో ఉంచాము .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అంటారు.

   మరియు ఈ సమయంలో మాత్రమే, అన్నింటికంటే చివరిగా, మేము ఇన్‌స్టాంటియేట్ చేస్తున్న క్లాస్ యొక్క కన్స్ట్రక్టర్‌ని పిలుస్తాము!

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

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

ఈ ప్రక్రియను బాగా అర్థం చేసుకోవడం ఎందుకు చాలా ముఖ్యం? మీరు "హుడ్ కింద" ఏమి జరుగుతుందో ఖచ్చితంగా తెలియకపోతే, ఒక సాధారణ వస్తువును సృష్టించే ఫలితాలు ఎంత ఊహించని విధంగా ఉంటాయో ఊహించండి :) ఇప్పుడు కోర్సుకు తిరిగి వచ్చి కొన్ని పనులను పూర్తి చేయడానికి సమయం ఆసన్నమైంది! అదృష్టం మరియు త్వరలో కలుద్దాం! :)