ลำดับของการกระทำระหว่างการสร้างวัตถุ

สวัสดี! บทเรียนวันนี้จะค่อนข้าง... เอ่อ... หลาย แง่มุม :) ในแง่ที่เราจะครอบคลุมหัวข้อที่หลากหลาย แต่ทั้งหมดจะเกี่ยวข้องกับกระบวนการสร้างวัตถุ เราจะวิเคราะห์ตั้งแต่ต้นจนจบ: วิธีเรียกคอนสตรัคเตอร์ วิธีและในฟิลด์คำสั่งใด (รวมถึงฟิลด์สแตติก) เริ่มต้นอย่างไร ฯลฯ ก่อนหน้านี้เราได้กล่าวถึงบางประเด็นที่กล่าวถึงในบทความ ดังนั้นคุณจึงสามารถมองข้าม วัสดุบน ตัวสร้าง คลาสพื้นฐาน ก่อนอื่น เรามานึกถึงวิธีการสร้างวัตถุกันก่อน คุณคงจำได้ดีว่ากระบวนการนี้มองจากมุมมองของนักพัฒนาอย่างไร เขาสร้างคลาส เขียนnewและทุกอย่างก็พร้อม :) ที่นี่เราจะพูดถึงสิ่งที่เกิดขึ้นภายในคอมพิวเตอร์และเครื่อง Java เมื่อเราเขียน ตัวอย่างเช่น:

Cat cat = new Cat();

เราเคยพูดถึงเรื่องนี้มาก่อนแล้ว แต่ในกรณีที่เราจะเตือนคุณ:

• ขั้นแรกให้จัดสรรหน่วยความจำสำหรับจัดเก็บวัตถุ
• ถัดไป เครื่อง Java สร้างการอ้างอิงถึงวัตถุ (ในกรณีของเรา การอ้างอิงคือ Cat 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);
   }
}

สำหรับเครื่อง Java กระบวนการจะมีลักษณะดังนี้:

1. สิ่งแรกที่เกิดขึ้นคือตัวแปรสแตติกของVehicleคลาสจะเริ่มต้น ใช่ ชั้นบอกว่าVehicleไม่ใช่ Truckตัวแปรสแตติกจะเริ่มต้นก่อนที่จะเรียกคอนสตรัคเตอร์ และจะเริ่มต้นในคลาสพาเรนต์ มาลองตรวจสอบสิ่งนี้กัน เราตั้งค่าvehicleCounterฟิลด์ในVehicleคลาสเท่ากับ 10 และพยายามแสดงทั้งในVehicleและTruckตัวสร้าง

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

   เราจงใจใส่คำสั่ง println ที่จุดเริ่มต้นของ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คลาสลูกเรียกว่า

   และเมื่อถึงจุดนี้สุดท้ายแล้ว ตัวสร้างของคลาสที่เรากำลังสร้างอินสแตนซ์จะถูกเรียก!

   เฉพาะในขั้นตอนที่หกฟิลด์จะได้รับการกำหนดค่าที่เราส่งผ่านเป็นอาร์กิวเมนต์ไปยังรถบรรทุกของเรา

   อย่างที่คุณเห็น การ "สร้าง" รถบรรทุก ซึ่งก็คือกระบวนการสร้างวัตถุนั้นไม่ง่ายเลย แต่ดูเหมือนว่าเราได้แยกมันออกเป็นส่วนที่เล็กที่สุดแล้ว :)

เหตุใดการทำความเข้าใจกระบวนการนี้จึงสำคัญมาก ลองนึกภาพว่าผลลัพธ์ของการสร้างวัตถุธรรมดาที่คาดไม่ถึงจะเป็นอย่างไรหากคุณไม่รู้ว่าเกิดอะไรขึ้น "ภายใต้ประทุน" :) ตอนนี้ได้เวลากลับไปที่หลักสูตรและทำงานบางอย่างให้เสร็จ! ขอให้โชคดี แล้วพบกันเร็ว ๆ นี้! :)