คอฟฟี่เบรค #114. ตัวสร้างเริ่มต้นใน Java เป็นตัวอย่างของตัวสร้างคลาส Maven vs Gradle: วิธีเลือกเครื่องมือสร้างที่เหมาะสม

ตัวสร้างเริ่มต้นใน Java - ตัวอย่างของตัวสร้างคลาส

ที่มา: FreeCodeCamp ในบทความนี้ เราจะพูดถึง Constructor วิธีสร้าง Constructor และ Constructor เริ่มต้นใน Java คืออะไร

ตัวสร้างคืออะไร?

ในฐานะที่เป็นคำศัพท์การเขียนโปรแกรมเชิงวัตถุตามคลาส ตัวสร้างเป็นวิธีการเฉพาะที่ใช้ในการเริ่มต้นวัตถุที่สร้างขึ้นใหม่ (คลาส) มีกฎหลายข้อที่คุณควรปฏิบัติตามเมื่อสร้างตัวสร้าง กฎเหล่านี้รวมถึง:

• ชื่อ Constructor ต้องตรงกับชื่อคลาส
• ตัวสร้างจะต้องไม่มีประเภทการส่งคืน

ก่อนที่เราจะดำเนินการต่อไป เรามาดูกันว่าคลาสใน Java มีลักษณะอย่างไร:

public class Student {
  String firstName;
  String lastName;
  int age;
}

โค้ดด้านบนแสดงคลาสStudentที่มีคุณสมบัติสามประการ - firstName , LastNameและage เราจะถือว่าชั้นเรียนควรเป็นแบบอย่างในการลงทะเบียนนักศึกษา โปรดจำไว้ว่าแอตทริบิวต์ทั้งสามนี้ไม่มีค่าใดๆ ดังนั้นข้อมูลในแอตทริบิวต์เหล่านี้จึงไม่ได้ฮาร์ดโค้ด ตอนนี้เราจะใช้คอนสตรัคเตอร์เพื่อสร้างอินสแตนซ์ใหม่ของ วัตถุ Student ของเรา :

public class Student {
  String firstName;
  String lastName;
  int age;

  //конструктор Student
  public Student(){
      firstName = "Ihechikara";
      lastName = "Abba";
      age = 100;
  }

  public static void main(String args[]) {
      Student myStudent = new Student();
      System.out.println(myStudent.age);
      // 100
  }
}

เราสร้างตัวสร้างที่เราใช้ในการ เริ่ม ต้นคุณลักษณะที่กำหนดไว้ใน วัตถุ นักเรียน โค้ดข้างต้นเป็นตัวอย่างของ ตัว สร้างที่ไม่มีอาร์กิวเมนต์ ตอนนี้เรามาดูตัวอย่างที่แตกต่างกัน:

public class Student {
  String firstName;
  String lastName;
  int age;

  //конструктор
  public Student(String firstName, String lastName, int age){
      this.firstName = firstName;
      this.lastName = lastName;
      this.age = age;
  }

  public static void main(String args[]) {
    Student myStudent = new Student("Ihechikara", "Abba", 100);
    System.out.println(myStudent.age);
  }

}

ตอนนี้เราได้สร้างคอนสตรัคเตอร์แบบกำหนดพารามิเตอร์แล้ว ตัวสร้างแบบพารามิเตอร์คือตัวสร้างที่สร้างขึ้นด้วยอาร์กิวเมนต์/พารามิเตอร์ ตอนนี้ขอเปลี่ยนมัน

public Student(String firstName, String lastName, int age){

  }

เราได้สร้างตัวสร้างใหม่ที่รับสามอาร์กิวเมนต์ - สองสตริงและจำนวนเต็มหนึ่งตัว

this.firstName = firstName;
this.lastName = lastName;
this.age = age;

จากนั้นเราเชื่อมโยงข้อโต้แย้งเหล่านี้กับคุณลักษณะที่เรากำหนดไว้เมื่อสร้างชั้นเรียนของเรา ตอนนี้เราได้เริ่มต้น วัตถุ Studentโดยใช้ตัวสร้างแล้ว

public static void main(String args[]) {
    Student myStudent = new Student("Ihechikara", "Abba", 100);
    System.out.println(myStudent.age);
  }

ในที่สุด เราก็สร้างอินสแตนซ์ใหม่ของ วัตถุ Studentและส่งข้อโต้แย้งของเราไปให้มัน เราสามารถทำได้เพราะเราได้กำหนดไว้ใน Constructor แล้ว ฉันสร้างคอนสตรัคเตอร์หนึ่งตัวโดยมีสามอาร์กิวเมนต์ แต่คุณสามารถสร้างคอนสตรัคเตอร์แยกกันเพื่อเริ่มต้นแต่ละแอตทริบิวต์ได้ ตอนนี้คุณรู้แล้วว่า Constructor คืออะไรใน Java และใช้งานอย่างไร มาดู Constructor เริ่มต้นกัน

ตัวสร้างเริ่มต้นคืออะไร?

Constructor เริ่มต้นคือ Constructor ที่สร้างโดยคอมไพเลอร์ หากเราไม่ได้กำหนด Constructor ใดๆ สำหรับคลาส นี่คือตัวอย่าง:

public class Student {
  String firstName;
  String lastName;
  int age;

  public static void main(String args[]) {
      Student myStudent = new Student();

      myStudent.firstName = "Ihechikara";
      myStudent.lastName = "Abba";
      myStudent.age = 100;

      System.out.println(myStudent.age);
      //100

      System.out.println(myStudent.firstName);
      //Ihechikara
  }
}

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

public class Student {
  String firstName;
  String lastName;
  int age;


  /* пустой конструктор, созданный компилятором. Этот конструктор не будет отображаться в вашем codeе*/
  Student() {

  }

  public static void main(String args[]) {
      Student myStudent = new Student();

      myStudent.firstName = "Ihechikara";
      myStudent.lastName = "Abba";
      myStudent.age = 100;

      System.out.println(myStudent.age);
      //100

      System.out.println(myStudent.firstName);
      //Ihechikara
  }
}

หลายๆ คนสับสนระหว่าง Constructor เริ่มต้นกับ Constructor ที่ไม่มีอาร์กิวเมนต์ แต่ใน Java พวกมันไม่เหมือนกัน ตัวสร้างใด ๆ ที่สร้างโดยโปรแกรมเมอร์ไม่ถือเป็นตัวสร้างเริ่มต้นใน Java

บทสรุป

ในบทความนี้ เราได้เรียนรู้ว่า Constructor คืออะไร และเราสามารถสร้างและใช้มันเพื่อเริ่มต้น Object ของเราได้อย่างไร นอกจากนี้เรายังพูดคุยเกี่ยวกับตัวสร้างเริ่มต้นและความแตกต่างระหว่างตัวสร้างที่ไม่มีข้อโต้แย้ง ขอให้มีความสุขในการเขียนโค้ด!

Maven vs Gradle: วิธีเลือกเครื่องมือสร้างที่เหมาะสม

ที่มา: Hackernoon Build ระบบอัตโนมัติเป็นส่วนสำคัญของการพัฒนาซอฟต์แวร์ ในบทความนี้ เราจะเปรียบเทียบเครื่องมือ สร้าง ยอดนิยมสองรายการสำหรับการพัฒนา Java: MavenและGradle

สร้างและ Apache Ant

ก่อนหน้านี้ นักพัฒนาใช้เครื่องมือ Make เพื่อสร้างโปรเจ็กต์ Java และกระบวนการสร้างก็ไม่แตกต่างจากการสร้างแอปพลิเคชันในภาษาอื่นมากนัก แต่ในปี 2000 ระบบการสร้าง An t (Another Neat Tool) ก็ได้เปิดตัว Ant ก็เหมือนกับ Make ที่ใช้สไตล์ที่จำเป็น และสคริปต์บิลด์ก็มีไวยากรณ์ XML Ant ได้รับการออกแบบให้เป็นระบบอัตโนมัติสำหรับโปรเจ็กต์ Java ดังนั้นนักพัฒนา Java จึงสามารถขยายฟังก์ชันการทำงานได้อย่างง่ายดาย

มาเวน

ในปี 2004 ระบบ Maven build ใหม่ออกมาและเปลี่ยนกระบวนการสร้างแอปพลิเคชัน Java ก่อนหน้านี้ นักพัฒนาเองได้จัดโครงสร้างโฟลเดอร์เพื่อจัดเก็บซอร์สโค้ด ทรัพยากร ไดเร็กทอรี classpath และไดเร็กทอรีเอาต์พุต ด้วยเหตุนี้ สคริปต์ Ant build สำหรับสองแอปพลิเคชันที่แตกต่างกันจึงอาจแตกต่างกันมาก: การคอมไพล์ การประกอบ การคัดลอกไฟล์ไปยังไดเร็กทอรีเอาต์พุต ฯลฯ ถูกเขียนแยกกัน ใน Maven โปรเจ็กต์ Java มีโครงสร้างที่ชัดเจนเสมอ ตัวอย่างเช่น แหล่งที่มาควรอยู่ใน src/main/java ทรัพยากรสำหรับการทดสอบควรอยู่ใน src/test/resources Maven ช่วยให้คุณสร้างโครงสร้างไฟล์ของโปรเจ็กต์ทั่วไปด้วยคำสั่งเดียว Maven ยังแนะนำแนวคิดของ “วงจรชีวิตการสร้าง” ด้วยเฟสตามลำดับ: ตรวจสอบ ➞ คอมไพล์ ➞ ทดสอบ ➞ แพ็คเกจ ➞ ตรวจสอบ ➞ ติดตั้ง ➞ ปรับใช้) ตอนนี้ ต้องขอบคุณโฟลเดอร์ที่มีโครงสร้างคงที่และชุดเป้าหมาย ทำให้ไม่จำเป็นต้องเขียนและ รักษาสคริปต์บิลด์ขนาดใหญ่ - พวกมันกลายเป็นสิ่งที่เปิดเผยแล้ว สะดวกยิ่งขึ้นสำหรับนักพัฒนาในการทำงานไม่เพียงแต่กับโค้ดของตนเองเท่านั้น แต่ยังรวมถึงโปรเจ็กต์ของบุคคลที่สามด้วย เพราะมันชัดเจนว่าซอร์สโค้ดทำงานอย่างไรและจะประกอบอย่างไร มีไลบรารีอยู่ไม่กี่แห่งในโลก Java และแอปพลิเคชันขนาดใหญ่ใช้งานหลายร้อยแห่ง หากคุณใช้ Ant โปรดจำไว้ว่าคุณจะต้องเพิ่มไฟล์ jar ที่จำเป็นให้กับโปรเจ็กต์ด้วยตัวเอง คุณต้องดูแลการพึ่งพาสกรรมกริยาที่จำเป็นด้วย Maven มอบฟังก์ชันการทำงานของตัวจัดการการพึ่งพาผ่าน Maven Central Repository ในตอนนี้ เมื่อระบุการขึ้นต่อกันใหม่ในสคริปต์บิลด์ Maven จะค้นหา jar ที่ต้องการของเวอร์ชันที่เกี่ยวข้องและการขึ้นต่อกันแบบสกรรมกริยาทั้งหมดโดยอัตโนมัติ ดาวน์โหลดพวกมันและตรวจสอบให้แน่ใจว่าพวกมันไปสิ้นสุดในคลาสพาธของโปรเจ็กต์ คุณยังสามารถดูแลรักษาพื้นที่เก็บข้อมูลส่วนตัวของคุณเองได้ โดยคุณสามารถจัดเก็บไลบรารีของคุณเองหรือไลบรารีที่มีแพตช์ หรือไลบรารีมาตรฐานที่สร้างขึ้นด้วยมือได้ ควรสังเกตว่า Ant สามารถใช้ร่วมกับApache Ivy Projectซึ่งช่วยให้คุณจัดการการพึ่งพาและทำงานกับที่เก็บ Maven แม้จะมีข้อดีทั้งหมดของ Maven แต่วิธีการประกาศก็อาจเป็นข้อเสียได้ในบางสถานการณ์ ตัวอย่างเช่น เมื่อคุณต้องการเปลี่ยนวงจรการใช้งานของบิวด์และเพิ่มเป้าหมายใหม่ให้กับกระบวนการบิวด์ ฟังก์ชัน Maven สามารถขยายได้โดยใช้ปลั๊กอิน มีปลั๊กอิน Maven สำเร็จรูปจำนวนมากที่ช่วยแก้ปัญหาต่างๆ ซึ่งทั้งหมดนี้หาได้จาก Maven Central Repository เช่นกัน แต่หากคุณจำเป็นต้องเปลี่ยนวงจรชีวิตมาตรฐานเล็กน้อยด้วยเหตุผลบางประการ และไม่มีปลั๊กอินที่เหมาะสม นักพัฒนาจะต้องสร้างมันขึ้นมาเอง

เกรเดิล

ระบบ Gradle build รุ่นแรกเปิดตัวในปี 2551 4 ปีต่อมา เวอร์ชัน 1.0 เปิดตัว เป้าหมายของโครงการ Gradle คือการรักษาผลประโยชน์ทั้งหมดของ Maven แต่ในขณะเดียวกันก็เพิ่มความสามารถในการปรับแต่งกระบวนการสร้าง สคริปต์ Gradle build เขียนด้วย Groovy DSL Gradle ช่วยให้คุณสามารถเขียนสคริปต์บิลด์ที่ประกาศได้และมีขนาดกะทัดรัดกว่า Maven เนื่องจาก XML ค่อนข้างใหญ่ คุณสามารถเพิ่มตรรกะที่กำหนดเองให้กับกระบวนการสร้าง Gradle ของคุณได้อย่างง่ายดาย สิ่งที่คุณต้องทำคือเขียนสคริปต์ Groovy และคุณไม่จำเป็นต้องพัฒนาปลั๊กอิน นักพัฒนาสามารถดีบักการทำงานของสคริปต์บิลด์ได้อย่างง่ายดาย เนื่องจากเป็นไฟล์ Groovy ทั่วไป ดังนั้น Gradle จึงรวมวิธีการประกาศและความจำเป็นเข้าด้วยกัน Gradle ยังรองรับปลั๊กอินด้วย ทำให้นักพัฒนาสามารถเปลี่ยนการตั้งค่าได้ ข้อดีอย่างหนึ่งที่สำคัญของ Gradle คือการสร้างส่วนเพิ่ม เมื่อรีสตาร์ทบิลด์ Gradle จะตรวจสอบว่าไฟล์อินพุตของเป้าหมายมีการเปลี่ยนแปลงหรือไม่ และหากไม่เป็นเช่นนั้น การดำเนินการของเป้าหมายจะถูกข้ามไปเนื่องจากอาร์ติแฟกต์เอาต์พุตได้ถูกสร้างขึ้นแล้ว สิ่งนี้ทำให้ความเร็วในการสร้างเพิ่มขึ้นอย่างมากเมื่อเทียบกับ Maven โดยเฉพาะในโปรเจ็กต์ขนาดใหญ่ที่มีหลายโมดูล Gradle ยังสามารถรัน Gradle daemon ซึ่งเป็นกระบวนการเบื้องหลังที่หลีกเลี่ยงการสิ้นเปลืองทรัพยากรและเวลาในการเริ่มต้นทุกครั้งที่รัน build Gradle มีฟีเจอร์ Gradle wrapper ที่มีประโยชน์ - ความสามารถในการสร้างเชลล์และสคริปต์คำสั่ง Windows ที่ดาวน์โหลดการแจกจ่าย Gradle ของเวอร์ชันที่ระบุโดยอัตโนมัติและใช้เพื่อสร้างโปรเจ็กต์ ซึ่งหมายความว่าในการสร้างโปรเจ็กต์ Gradle คุณไม่จำเป็นต้องติดตั้ง Gradle แยกต่างหาก เพียงแค่ติดตั้ง Java หากจำเป็น คุณสามารถสลับโปรเจ็กต์ของคุณเป็น Gradle เวอร์ชันอื่นได้อย่างง่ายดาย

การเลือกระหว่าง Maven และ Gradle

แม้จะมีประโยชน์ของ Gradle แต่ก็มีบางโปรเจ็กต์ที่ใช้ระบบ Maven build ทางเลือกขึ้นอยู่กับประเภทของโครงการและทีมงาน Maven มีการใช้งานมาตั้งแต่ปี 2547 ดังนั้นนักพัฒนาจึงคุ้นเคยกับมันมากขึ้น นอกจากนี้ Maven ยังมีความเสถียร เวอร์ชันหลักล่าสุด 3 เปิดตัวในปี 2010 Gradle มีการเปลี่ยนแปลงอย่างมีนัยสำคัญหลายครั้งโดยไม่มีความเข้ากันได้แบบย้อนหลัง และนักพัฒนาจำเป็นต้องย้ายสคริปต์การสร้างเป็นเวอร์ชันใหม่ เนื่องจากไม่ใช่ทุกคนที่คุ้นเคยกับ Groovy หรือ Kotlin การทำงานกับ Gradle จึงต้องใช้ความรู้เพิ่มเติม ในขณะที่ Maven ใช้ XML ที่ชัดเจน สิ่งนี้ทำให้เกิดคำถาม: หากโครงการเริ่มพัฒนาก่อนที่ Gradle จะได้รับความนิยม การย้ายสคริปต์การสร้างไปที่ Gradle สมเหตุสมผลหรือไม่ ในด้านหนึ่ง มีนักพัฒนาจำนวนมากขึ้นเรื่อยๆ ที่เลือกใช้ Gradle ตัวอย่างเช่น Spring, Hibernate และ LinkedIn ใช้ Gradle ระบบบิลด์ Android ก็เป็น Gradle เหมือนกัน และโดยทั่วไปก็เป็นที่นิยมในหมู่นักพัฒนาแอปพลิเคชัน Android ในทางกลับกัน IDE ที่รู้จักกันดีทั้งหมดมีการบูรณาการกับทั้งระบบบิลด์และรองรับการเติมข้อความอัตโนมัติเมื่อแก้ไขสคริปต์บิลด์ เช่นเดียวกับ Maven Gradle มีปลั๊กอินจำนวนมากที่ให้คุณเพิ่มฟังก์ชันที่ใช้บ่อยให้กับกระบวนการสร้างโปรเจ็กต์ได้

บทสรุป

จากข้อดีข้อเสียของแต่ละระบบการประกอบที่อธิบายไว้ข้างต้น สามารถสรุปได้ดังต่อไปนี้ Maven เหมาะสำหรับโปรเจ็กต์ขนาดเล็กที่ไม่ต้องการการปรับแต่งกระบวนการสร้าง และระยะเวลาในการสร้างโปรเจ็กต์ก็ไม่สำคัญนัก Gradle เหมาะสำหรับโปรเจ็กต์ขนาดใหญ่ที่มีโมดูลจำนวนมากรวมถึงแอปพลิเคชัน Android