Pagkakasunud-sunod ng mga aksyon sa panahon ng paglikha ng bagay

Hi! Ang aralin ngayon ay magiging medyo... uh... multifaceted :) sa kahulugan na tatalakayin natin ang isang malawak na hanay ng mga paksa, ngunit lahat sila ay nauugnay sa proseso ng paglikha ng bagay . Pagkakasunud-sunod ng mga aksyon sa panahon ng paglikha ng bagay - 1

Susuriin namin ito mula simula hanggang katapusan: kung paano tinawag ang mga konstruktor, paano at sa anong pagkakasunud-sunod ng mga patlang (kabilang ang mga static na patlang) ay sinisimulan, atbp. Nauna naming nahawakan ang ilan sa mga puntong tinalakay sa artikulo, para masulyapan mo ang materyal sa base class constructors . Una, alalahanin natin kung paano nilikha ang isang bagay. Naaalala mong mabuti kung ano ang hitsura ng prosesong ito mula sa pananaw ng isang developer: lumikha siya ng isang klase, nagsusulat new, at handa na ang lahat :) Dito ay pag-uusapan natin kung ano ang nangyayari sa loob ng computer at ang Java machine kapag sumulat tayo, halimbawa:

Cat cat = new Cat();

Napag-usapan na namin ito dati, ngunit kung sakaling ipaalala namin sa iyo:

Una, ang memorya para sa pag-iimbak ng bagay ay inilalaan.
Susunod, ang Java machine ay lumilikha ng isang sanggunian sa bagay (sa aming kaso ang sanggunian ay Cat cat).
Sa wakas, ang mga variable ay sinisimulan at ang constructor ay tinatawag (titingnan natin ang prosesong ito nang mas detalyado).

Bilang karagdagan, mula sa aralin sa ikot ng buhay ng bagay , malamang na naaalala mo na ang isang bagay ay tumatagal hangga't mayroong kahit isang reference dito. Kung walang natitira, ang bagay ay magiging biktima ng kolektor ng basura. Pagkakasunud-sunod ng mga aksyon sa panahon ng paglikha ng bagay - 2

Pagkakasunud-sunod ng mga aksyon sa panahon ng paglikha ng bagay - 2

Ang unang dalawang puntong ito ay hindi dapat magtaas ng anumang mga espesyal na tanong. Ang paglalaan ng memorya ay isang simpleng proseso, at mayroon lamang dalawang posibleng resulta: maaaring mayroong memorya o wala :) At ang paglikha ng isang link ay hindi pangkaraniwan. Ngunit ang ikatlong punto ay kumakatawan sa isang buong hanay ng mga operasyon na isinagawa sa mahigpit na pagkakasunud-sunod. Hindi ako fan ng cramming para sa mga pagsubok, ngunit kailangan mong maunawaan nang mabuti ang prosesong ito at kailangan mong kabisaduhin ang pagkakasunod-sunod ng mga operasyong ito. Noong pinag-usapan natin ang proseso ng paglikha ng bagay sa mga nakaraang aralin, wala ka pa talagang alam tungkol sa pamana, kaya may problema ang pagpapaliwanag ng ilang bagay. Ngayon ay marami ka nang nalalaman at maaari na nating isaalang-alang ang tanong na ito nang buo :) Kaya ang ikatlong punto ay nagsasabing " Sa wakas, ang mga variable ay sinisimulan at ang tagabuo ay tinawag. " Ngunit sa anong pagkakasunud-sunod nangyayari ang lahat ng ito? Para sa isang mas mahusay na pag-unawa, gumawa tayo ng dalawang napakasimpleng klase — isang magulang at isang anak:

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++;
   }
}

Ang Truckklase ay isang pagpapatupad ng isang trak na may mga field na kumakatawan sa taon, modelo, at pinakamataas na bilis nito. Ngayon gusto naming lumikha ng isang tulad na bagay:

public class Main {

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

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

Para sa Java machine, ang proseso ay magiging ganito:

Ang unang bagay na mangyayari ay ang mga static na variable ng Vehicleklase ay pinasimulan . Oo, sinabi ko ang Vehicleklase, hindi Truck. Sinisimulan ang mga static na variable bago tawagin ang mga constructor, at magsisimula ito sa parent class. Subukan nating i-verify ito. Itinakda namin ang vehicleCounterpatlang sa Vehicleklase na katumbas ng 10 at subukang ipakita ito sa parehong Vehicleat Truckmga konstruktor.

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++;
   }
}

Sinadya naming ilagay ang println statement sa pinakasimula ng Truckconstructor upang matiyak na ang mga field ng trak ay hindi pa nasisimulan kapag vehicleCounteripinakita.

At narito ang resulta:

10
10

Pagkatapos masimulan ang mga static na variable ng parent class, ang mga static na variable ng child class ay sinisimulan. Sa aming kaso, ito ang truckCounterlarangan ng Truckklase.

Gumawa tayo ng isa pang eksperimento kung saan susubukan nating ipakita ang halaga ng truckCounterloob ng Truckconstructor bago masimulan ang iba pang mga field:

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++;
   }
}

Gaya ng nakikita mo, ang value 10 ay naitalaga na sa aming static na variable kapag Trucknagsimula ang constructor.

Hindi pa oras para sa mga constructor! Nagpapatuloy ang variable initialization. Ang mga di-static na variable ng parent na klase ay pinasimulan sa pangatlo. Tulad ng nakikita mo, ang pamana ay makabuluhang nagpapakumplikado sa proseso ng paglikha ng isang bagay, ngunit wala kang magagawa tungkol dito: Kailangan mo lamang na kabisaduhin ang ilang mga bagay sa programming :)

Bilang isang eksperimento, maaari tayong magtalaga ng ilang paunang halaga sa descriptionvariable sa Vehicleklase, at pagkatapos ay baguhin ito sa constructor.
```
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;
   }
}
```
Patakbuhin natin ang aming main()pamamaraan na lumilikha ng isang trak:
```
public class Main {

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

       Truck truck = new Truck(2017, "Scania S 500 4x2", 220);
   }
}
```
Nakukuha namin ang sumusunod na resulta:
```
Initial value of the description field
Vehicle
```
Ito ay nagpapatunay na kapag Vehiclenagsimula ang tagabuo ang descriptionpatlang ay naitalaga na ng isang halaga.
Sa wakas, oras na para sa mga konstruktor! Mas tiyak, oras na para sa base class constructor. Ito ay tinatawag sa ikaapat na hakbang ng proseso ng paglikha ng bagay.

Medyo madali din itong i-verify. Subukan nating mag-output ng dalawang linya sa console: ang isa sa loob ng Vehiclebase class constructor, ang pangalawa sa loob ng Truckconstructor. Kailangan nating kumbinsihin na ang linya sa loob Vehicleay unang ipinapakita:
```
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++;
}
```
Tatakbuhin namin ang aming main()pamamaraan at titingnan ang resulta:
```
Hello from the Vehicle constructor!
Hello from the Truck constructor!
```
Magaling. Ibig sabihin hindi tayo nagkakamali :) Let's move on.

Ngayon ay oras na para sa pagsisimula ng mga non-static na field ng child class, ibig sabihin, ang aming Truckklase. Ang mga field kaagad sa loob ng klase na ginagawang instant ay hindi sinisimulan hanggang sa ikalimang hakbang! Nakakagulat, ngunit totoo :) Muli, gagawa kami ng isang simpleng pagsusuri — tulad ng sa klase ng magulang: magkakaroon kami ng ilang paunang halaga sa maxSpeedvariable at sa Truckconstructor ay susuriin namin na ang halaga ay itinalaga bago magsimula ang konstruktor:

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++;
   }
}

Output ng console:

Initial value of maxSpeed = 150

Tulad ng nakikita mo,  kapag Truck nagsimula ang tagabuo, maxSpeed ay katumbas na ng 150!

Ang tagabuo ng Truckklase ng bata ay tinatawag.

At tanging sa puntong ito, ang huli sa lahat, tatawagin ang constructor ng klase na ginagawa natin!

Sa ikaanim na hakbang lamang itatalaga sa mga patlang ang mga halaga na ipinapasa namin bilang mga argumento sa aming trak.

Tulad ng nakikita mo, ang "paggawa" ng isang trak, ibig sabihin, ang proseso ng paglikha ng bagay, ay hindi simple. Ngunit tila nahati namin ito sa pinakamaliit na bahagi :)

Pagkakasunud-sunod ng mga aksyon sa panahon ng paglikha ng bagay - 3

Bakit napakahalagang maunawaang mabuti ang prosesong ito? Isipin kung gaano hindi inaasahan ang mga resulta ng paglikha ng isang ordinaryong bagay kung hindi mo alam kung ano mismo ang nangyayari "sa ilalim ng talukbong" :) Ngayon ay oras na upang bumalik sa kurso at kumpletuhin ang ilang mga gawain! Good luck at makita ka sa lalong madaling panahon! :)