คอฟฟี่เบรค #230. Records ใน Java คืออะไรและทำงานอย่างไร

ที่มา: JavaTechOnline บทความนี้ให้ข้อมูลเชิงลึกเกี่ยวกับแนวคิดของ Records ใน Java พร้อมตัวอย่าง รวมถึงไวยากรณ์ วิธีสร้าง และวิธีใช้งาน Records ใน Java เป็นหนึ่งในคุณสมบัติที่ยอดเยี่ยมที่เปิดตัวครั้งแรกใน Java 14 ในรูปแบบการแสดงตัวอย่างและในที่สุดก็ออกมาในรุ่น Java 17 นักพัฒนาหลายคนใช้งานมันอย่างแข็งขันซึ่งช่วยให้พวกเขาลดโค้ดสำเร็จรูปจำนวนมากได้สำเร็จ ยิ่งไปกว่านั้น ต้องขอบคุณบันทึกที่ทำให้คุณไม่ต้องเขียนโค้ดแม้แต่บรรทัดเดียวเพื่อทำให้คลาสไม่เปลี่ยนรูป

เมื่อใดจึงควรใช้ Record ใน Java?

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

ฉันจะใช้บันทึกใน Java ได้ที่ไหน

โดยทั่วไป เราสามารถใช้บันทึกในสถานการณ์ใดๆ ที่เราจำเป็นต้องประกาศคอนเทนเนอร์ข้อมูลแบบธรรมดาที่มีคุณสมบัติไม่เปลี่ยนรูปและวิธีการที่สร้างขึ้นโดยอัตโนมัติ ตัวอย่างเช่น ต่อไปนี้เป็นกรณีการใช้งานบางส่วนที่บันทึกอาจมีประโยชน์: Data Transfer Object (DTO): เราสามารถใช้ Record เพื่อประกาศอ็อบเจ็กต์การถ่ายโอนข้อมูลแบบธรรมดาที่มีข้อมูลได้ สิ่งนี้มีประโยชน์เมื่อถ่ายโอนข้อมูลระหว่างชั้นแอปพลิเคชันที่แตกต่างกัน เช่น ระหว่างชั้นบริการและชั้นฐานข้อมูล ออบเจ็กต์การกำหนดค่า : เรกคอร์ดสามารถใช้เพื่อประกาศออบเจ็กต์การกำหนดค่าที่มีชุดของคุณสมบัติการกำหนดค่าสำหรับแอปพลิเคชันหรือโมดูล โดยทั่วไปออบเจ็กต์เหล่านี้มีคุณสมบัติที่ไม่เปลี่ยนรูป ทำให้ปลอดภัยต่อเธรดและใช้งานง่าย วัตถุคุณค่า บันทึกสามารถใช้เพื่อประกาศออบเจ็กต์ค่าที่มีชุดค่าที่แสดงถึงแนวคิดหรือโมเดลโดเมนเฉพาะ การตอบสนองของ API : เมื่อสร้าง REST API โดยทั่วไปข้อมูลจะถูกส่งกลับในรูปแบบของ JSON หรือ XML ในกรณีเช่นนี้ คุณอาจต้องกำหนดโครงสร้างข้อมูลอย่างง่ายที่แสดงถึงการตอบสนองของ API ระเบียนเหมาะอย่างยิ่งสำหรับสิ่งนี้เนื่องจากช่วยให้คุณสามารถกำหนดโครงสร้างข้อมูลที่มีน้ำหนักเบาและไม่เปลี่ยนรูปแบบซึ่งสามารถทำให้เป็นอนุกรมเป็น JSON หรือ XML ได้อย่างง่ายดาย ข้อมูลการทดสอบ เมื่อเขียนการทดสอบหน่วย คุณมักจะต้องสร้างข้อมูลการทดสอบที่แสดงถึงสถานการณ์เฉพาะ ในกรณีเช่นนี้ คุณอาจต้องกำหนดโครงสร้างข้อมูลอย่างง่ายที่แสดงถึงข้อมูลทดสอบ เรกคอร์ดอาจเหมาะอย่างยิ่งสำหรับสิ่งนี้ เนื่องจากช่วยให้เรากำหนดโครงสร้างข้อมูลที่มีน้ำหนักเบาและไม่เปลี่ยนรูปได้โดยใช้โค้ดสำเร็จรูปที่น้อยที่สุด วัตถุที่มีลักษณะคล้าย Tuple : สามารถใช้บันทึกเพื่อประกาศวัตถุที่มีลักษณะคล้าย Tuple ซึ่งมีจำนวนค่าที่เกี่ยวข้องคงที่ สิ่งนี้มีประโยชน์เมื่อส่งคืนค่าหลายค่าจากวิธีการหนึ่งหรือเมื่อทำงานกับคอลเลกชันของค่าที่เกี่ยวข้อง

บันทึกใน Java คืออะไร?

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

record Record_Name(Fields....)

จะสร้างและใช้ Record ใน Java พร้อมตัวอย่างได้อย่างไร

เรามาดูวิธีการสร้างและใช้บันทึกใน Java โดยทางโปรแกรมกัน

การสร้างบันทึก

การสร้างบันทึกโดยทางโปรแกรมไม่เหมือนกับการสร้างคลาสปกติใน Java มากนัก แทนที่จะใช้class เราใช้ คำว่า recordแทน คุณต้องประกาศฟิลด์ที่มีประเภทข้อมูลอยู่ในวงเล็บของชื่อเรกคอร์ดด้วย นี่คือตัวอย่างโค้ดที่สาธิตวิธีการสร้างรายการใน Java:

public record Book(String name, double price) { }

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

การใช้บันทึก

หากต้องการใช้บันทึกใน Java เราสามารถสร้างอินสแตนซ์โดยใช้คีย์เวิร์ดใหม่ได้ เช่นเดียวกับที่เราทำกับคลาสทั่วไป นี่คือตัวอย่าง:

Book book = new Book( "Core Java" , 324.25);

ที่นี่อินสแตนซ์บันทึก Book ใหม่ จะถูกสร้างขึ้นโดยตั้ง ค่าฟิลด์ ชื่อเป็นCore Javaและ ฟิลด์ ราคาตั้งค่าเป็น324.25 เมื่อสร้างบันทึกแล้ว คุณจะสามารถเข้าถึงฟิลด์ต่างๆ ได้โดยใช้ชื่อของฟิลด์นั้นเอง ไม่มีวิธีรับหรือตั้งค่า ชื่อฟิลด์จะกลายเป็นชื่อวิธีการแทน

String name = book.name();

double price = book.price();

ที่ นี่ เราเห็นค่าของฟิลด์ชื่อและราคา ที่ถูกดึงมา จาก บันทึก Book นอกจากเขตข้อมูลแล้ว เรกคอร์ดยังมีวิธีการในตัวที่คุณสามารถใช้เพื่อจัดการข้อมูลเหล่านั้นได้ ตัวอย่างเช่นtoString() , เท่ากับ()และ hashCode ( ) โปรดจำไว้ว่าระเบียน Java จะไม่เปลี่ยนรูปตามค่าเริ่มต้น ซึ่งหมายความว่าเมื่อสร้างขึ้นแล้ว สถานะจะไม่สามารถเปลี่ยนแปลงได้ ลองดูอีกตัวอย่างหนึ่งของวิธีสร้างและใช้บันทึกใน Java มาดูกรณีที่เราต้องการบันทึกเพื่อจัดเก็บข้อมูลเกี่ยวกับนักเรียน

public record Student(String name, int age, String subject) {}

ซึ่งจะ สร้างบันทึกชื่อStudentโดยมีสามฟิลด์: ชื่ออายุและหัวเรื่อง เราสามารถสร้างอินสแตนซ์ของรายการนี้ได้ดังนี้:

Student student = new Student("John Smith", 20, "Computer Science");

จากนั้นเราสามารถรับค่าฟิลด์โดยใช้ชื่อฟิลด์:

String name = student.name();
int age = student.age();
String subject= student.subject();

บันทึกจะมีลักษณะอย่างไรหลังจากการรวบรวม?

เนื่องจากRecordเป็นเพียงคลาสชนิดพิเศษ คอมไพเลอร์จึงแปลงคลาสนั้นให้เป็นคลาสปกติด้วย แต่มีข้อจำกัดและความแตกต่างบางประการ เมื่อคอมไพลเลอร์แปลงบันทึก (ไฟล์ Java) เป็นไบต์โค้ดหลังจากกระบวนการคอมไพล์ ไฟล์ .class ที่สร้างขึ้น จะมีการประกาศเพิ่มเติมบางอย่างของ คลาส Record ตัวอย่างเช่น ด้านล่างนี้คือโค้ดไบต์ที่สร้างขึ้นสำหรับ รายการ Studentโดยคอมไพลเลอร์ Java:

record Student(String name, int age) {   }

กำลังเขียนไปยังไฟล์ .class (หลังจากการคอมไพล์)

นอกจากนี้เรายังสามารถค้นหาคลาสที่แปลงด้านล่างหากเราใช้ เครื่องมือ javapและใช้คำสั่งด้านล่างจากบรรทัดคำสั่ง สิ่งสำคัญที่ควรทราบคือบรรทัดคำสั่ง Java มี เครื่องมือ javapซึ่งคุณสามารถใช้เพื่อดูข้อมูลเกี่ยวกับฟิลด์ ตัวสร้าง และเมธอดของไฟล์คลาสได้ >javap Student Conclusion: หากเราตรวจสอบ bytecode อย่างระมัดระวัง เราอาจมีข้อสังเกตบางประการ:

• คอมไพเลอ ร์ แทนที่ คีย์เวิร์ดRecordด้วยคลาส
• คอมไพเลอร์ประกาศคลาสขั้นสุดท้าย นี่บ่งชี้ว่าคลาสนี้ไม่สามารถขยายได้ นี่ก็หมายความว่ามันไม่สามารถสืบทอดได้และไม่เปลี่ยนรูปในธรรมชาติ
คลาสที่แปลงแล้วขยายjava.lang.Record สิ่งนี้บ่งชี้ว่าบันทึกทั้งหมดเป็นคลาสย่อยของคลาส Recordที่กำหนดไว้ใน แพ็คเกจ java.lang
• คอมไพเลอร์เพิ่มตัวสร้างแบบพารามิเตอร์
• คอมไพเลอร์จะสร้างเมธอดtoString() , hashCode()และเท่ากับ() โดย อัตโนมัติ
• คอมไพเลอร์ได้เพิ่มวิธีการในการเข้าถึงฟิลด์ โปรดใส่ใจกับหลักการตั้ง ชื่อเมธอด - มันเหมือนกับชื่อฟิลด์ทุกประการ ไม่ควรมีการรับหรือตั้งค่า ก่อนชื่อฟิลด์

เขตข้อมูลในเรกคอร์ด

เรคคอร์ดใน Java กำหนดสถานะโดยใช้ชุดฟิลด์ โดยแต่ละฟิลด์มีชื่อและประเภทที่แตกต่างกัน ฟิลด์ของเรคคอร์ดจะถูกประกาศในส่วนหัวของเรคคอร์ด ตัวอย่างเช่น:

public record Person(String name, int age) {}

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

public record Person(String name, int age) {

   static String sex;
}

ตัวสร้างในบันทึก

เช่นเดียวกับตัวสร้างคลาสแบบดั้งเดิม ตัวสร้างเร็กคอร์ดถูกใช้เพื่อสร้างอินสแตนซ์ของเร็กคอร์ด Records มีสองแนวคิดเกี่ยวกับตัวสร้าง: ตัว สร้างตามรูปแบบบัญญัติ และตัวสร้างแบบกะทัดรัด ตัวสร้างแบบกะทัดรัดให้วิธีที่กระชับยิ่งขึ้นในการเริ่มต้นตัวแปรสถานะในบันทึก ในขณะที่ตัวสร้างแบบมาตรฐานให้วิธีแบบดั้งเดิมและมีความยืดหยุ่นมากกว่า

ตัวสร้างมาตรฐาน

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

public record Person(String name, int age) {

       public Person(String name, int age) {
           if (age < 18) {
              throw new IllegalArgumentException("You are not allowed to participate in general elections");
           }
      }
}

นักออกแบบขนาดกะทัดรัด

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

public record Person(String name, int age) {

      public Person {
          if (age < 18) {
              throw new IllegalArgumentException("You are not allowed to participate in general elections");
          }
     }
}

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

วิธีการในบันทึก

เรคคอร์ดใน Java จะสร้างชุดวิธีการสำหรับแต่ละฟิลด์ในเรคคอร์ดโดยอัตโนมัติ วิธีการเหล่านี้เรียกว่าวิธีการเข้าถึงและมีชื่อเดียวกันกับฟิลด์ที่เกี่ยวข้อง ตัวอย่างเช่น หากบันทึกมีช่องชื่อpriceก็จะมีเมธอดที่เรียกว่า price() โดยอัตโนมัติซึ่งจะส่งกลับค่าของ ช่อง ราคา นอกจากเมธอด accessor ที่สร้างขึ้นโดยอัตโนมัติแล้ว เรายังสามารถกำหนดเมธอดของเราเองในรายการได้ เช่นเดียวกับในคลาสทั่วไป ตัวอย่างเช่น:

public record Person(String name, int age) {
   public void sayHello() {
      System.out.println("Hello, my name is " + name);
   }
}

รายการ นี้ มี เมธอด sayHello()ที่พิมพ์คำทักทายโดยใช้ ฟิลด์ ชื่อ

Record ช่วยลดโค้ดสำเร็จรูปได้อย่างไร

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

public class Person {

    private String name;
    private int age;
    private String email;

    public Person(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }

    public String getName() {

       return name;
    }

    public int getAge() {
       return age;
    }

    publicString getEmail() {
       return email;
    }

    public void setName(String name) {
       this.name = name;
    }

    public voidsetAge(int age) {
       this.age = age;
    }

    public void setEmail(String email) {
       this.email = email;
    }

    @Override
    public String toString() {
       return "Person{" +
         "name='" + name + '\'' +
         ", age=" + age +
         ", email='" + email + '\'' +
      '}';
    }
}

ดังที่เราเห็นแล้วว่าคลาสนี้ต้องการโค้ดสำเร็จรูปจำนวนมากเพื่อกำหนดฟิลด์ ตัวสร้าง getters ตัวตั้งค่า และเมธอดtoString () นอกจากนี้ สมมติว่าเราต้องการทำให้คลาสนี้ไม่เปลี่ยนรูป ในการดำเนินการนี้ เราจะต้องทำตามขั้นตอนเพิ่มเติม เช่น:

• ประกาศคลาสเป็นที่สิ้นสุดเพื่อไม่ให้ขยายได้
• ประกาศเขตข้อมูลทั้งหมดเป็นส่วนตัวและเป็นเขตสุดท้ายเพื่อไม่ให้มีการเปลี่ยนแปลงภายนอกตัวสร้าง
• ไม่ต้องระบุ วิธี การตั้งค่า ใดๆ สำหรับช่อง
• หากฟิลด์ใดฟิลด์หนึ่งไม่แน่นอน คุณควรส่งคืนสำเนาของฟิลด์เหล่านั้นแทนการส่งคืนออบเจ็กต์ต้นฉบับ

รหัสที่ใช้บันทึก :

public record Person(String name, int age, String email) {}

นั่นคือทั้งหมด! ด้วยโค้ดเพียงบรรทัดเดียว เราได้กำหนดคลาสที่มีฟิลด์, Constructor, Getters, Setters และ เมธอด toString()เหมือนกับคลาสดั้งเดิม ไวยากรณ์Recordจะดูแลโค้ดสำเร็จรูปทั้งหมดให้เรา จากตัวอย่างข้างต้น เห็นได้ชัดว่าการใช้บันทึกใน Java สามารถช่วยกำจัดโค้ดสำเร็จรูปได้โดยการจัดเตรียมไวยากรณ์ที่กระชับมากขึ้นสำหรับการกำหนดคลาสด้วยชุดฟิลด์คงที่ ต้องใช้รหัสน้อยลงในการกำหนดและใช้เรกคอร์ดมากกว่าวิธีการแบบเดิม และเรกคอร์ดให้การเข้าถึงโดยตรงไปยังฟิลด์โดยใช้วิธีการอัปเดตฟิลด์ ทำให้โค้ดอ่านง่ายขึ้น บำรุงรักษาได้ และเกิดข้อผิดพลาดน้อยลง นอกจากนี้ ด้วย ไวยากรณ์ Recordเราไม่จำเป็นต้องทำอะไรเพิ่มเติมเพื่อทำให้คลาสไม่เปลี่ยนรูป ตามค่าเริ่มต้น ฟิลด์ทั้งหมดในเรกคอร์ดถือเป็นที่สิ้นสุดและตัวคลาสเรกคอร์ดเองจะไม่เปลี่ยนรูป ดังนั้น การสร้างคลาสที่ไม่เปลี่ยนรูปโดยใช้ไวยากรณ์การเขียนจึงง่ายกว่ามากและใช้โค้ดน้อยกว่าวิธีการแบบเดิม ด้วยบันทึก เราไม่จำเป็นต้องประกาศเขตข้อมูลเป็นFinalจัดเตรียม Constructor ที่เตรียมข้อมูลเบื้องต้นให้กับฟิลด์ หรือระบุ Getters สำหรับทุกฟิลด์

คลาสบันทึกทั่วไป

Java ยังสามารถกำหนด คลาส Records ทั่วไป ได้ คลาสรายการทั่วไปคือคลาสรายการที่มีพารามิเตอร์ประเภทตั้งแต่หนึ่งรายการขึ้นไป นี่คือตัวอย่าง:

public record Pair<T, U>(T first, U second) {}

ในตัวอย่างนี้คู่คือคลาสบันทึกทั่วไปที่รับพารามิเตอร์สองตัวประเภทTและU เราสามารถสร้างอินสแตนซ์ของบันทึกนี้ได้ดังนี้:

Pair<String, Integer>pair = new Pair<>( "Hello" , 123);

คลาสที่ซ้อนกันภายใน Record

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

public record Person(String name, int age, Contact contact){

    public static class Contact {

       private final String email;
       private final String phone;

       public Contact(String email, String phone){
           this.email = email;
           this.phone = phone;
       }

       public String getEmail(){
          return email;
       }

       public String getPhone(){
          return phone;
       }
    }
}

ในตัวอย่างนี้Personคือรายการที่มี คลาส Contact ที่ซ้อน กัน ในทางกลับกันผู้ติดต่อเป็นคลาสที่ซ้อนกันแบบคงที่ซึ่งมีฟิลด์ส่วนตัวสุดท้ายสองฟิลด์: ที่อยู่อีเมลและโทรศัพท์ นอกจากนี้ยังมี Constructor ที่รับอีเมลและหมายเลขโทรศัพท์ และ getter สองวิธี: getEmail ()และgetPhone() เราสามารถสร้าง อินสแตนซ์บุคคลได้ดังนี้:

Person person = new Person("John",30, new Person.Contact("john@example.com", "123-456-7890"));

ในตัวอย่างนี้ เราได้สร้าง ออบเจ็กต์ Person ใหม่ ชื่อJohn อายุ 30 ปี และ ออบเจ็กต์ Contact ใหม่ ด้วยอีเมล john@example.com และโทรศัพท์123-456-7890

อินเทอร์เฟซที่ซ้อนกันภายในบันทึก

นี่คือตัวอย่างรายการที่มีอินเทอร์เฟซแบบซ้อน:

public record Book(String title, String author, Edition edition){
    public interface Edition{
       String getName();
   }
}

ในตัวอย่างนี้Bookคือรายการที่มีอินเท อร์เฟ ซ Edition ที่ซ้อนกัน ในทางกลับกันEdition คืออินเทอร์ เฟ ซที่กำหนดเมธอด getName()เดียว เราสามารถสร้าง อินสแตนซ์Bookได้ดังนี้:

Book book = new Book("The Hitchhiker's Guide to the Galaxy", "Douglas Adams", new Book.Edition() {

   public String getName() {

      return "Science Fiction";
   }
});

ในตัวอย่างนี้ เราสร้าง ออบเจ็กต์ Book ใหม่ ที่มีชื่อว่าThe Hitchhiker's Guide to the GalaxyโดยDouglas Adamsและการใช้งาน อินเทอร์เฟ ซ Edition โดยไม่ระบุชื่อใหม่ ซึ่งจะส่งคืนชื่อScience Fictionเมื่อ เรียก ใช้ เมธอด getName()

Records สามารถทำอะไรได้อีก?

• รายการสามารถกำหนดตัวสร้างแบบกำหนดเองได้ บันทึกรองรับตัวสร้างแบบพารามิเตอร์ ซึ่งสามารถเรียกตัวสร้างเริ่มต้นพร้อมพารามิเตอร์ที่ให้ไว้ในเนื้อหาได้ นอกจากนี้ เรกคอร์ดยังสนับสนุนตัวสร้างแบบกะทัดรัด ซึ่งคล้ายกับตัวสร้างเริ่มต้น แต่สามารถรวมฟังก์ชันเพิ่มเติม เช่น การตรวจสอบในเนื้อความของตัวสร้าง
• เช่นเดียวกับคลาสอื่นๆ ใน Java Record สามารถกำหนดและใช้วิธีการอินสแตนซ์ได้ ซึ่งหมายความว่าเราสามารถสร้างและเรียกใช้วิธีการเฉพาะสำหรับคลาสการบันทึกได้
• ในRecordไม่อนุญาตให้กำหนดตัวแปรอินสแตนซ์เป็นสมาชิกคลาส เนื่องจากสามารถระบุเป็นพารามิเตอร์ตัวสร้างเท่านั้น อย่างไรก็ตาม เรกคอร์ดรองรับฟิลด์แบบคงที่และวิธีการแบบคงที่ ซึ่งสามารถใช้เพื่อจัดเก็บและเข้าถึงข้อมูลทั่วไปสำหรับอินสแตนซ์ทั้งหมดของคลาสเรกคอร์ด

บันทึกสามารถใช้อินเทอร์เฟซได้หรือไม่?

ใช่ การเขียนด้วย Java สามารถใช้อินเทอร์เฟซได้ ตัวอย่างเช่น รหัสด้านล่างแสดงให้เห็นถึงแนวคิด:

public interface Printable {
   void print();
}

public record Person(String name, int age) implements Printable {
   public void print() {
      System.out.println("Name: " + name + ", Age: " + age);
   }
}

ที่นี่เราได้กำหนด อินเทอร์ เฟ ซ สำหรับพิมพ์ด้วย เมธอด print() เดียว นอกจากนี้เรายังกำหนด รายการ บุคคลที่ใช้ อิน เท อร์เฟซ สำหรับพิมพ์ บันทึกบุคคลมีสองฟิลด์: ชื่อและอายุและแทนที่ วิธีการพิมพ์ของอิน เท อร์เฟซ สำหรับพิมพ์เพื่อพิมพ์ค่าของฟิลด์เหล่านี้ เราสามารถยกตัวอย่าง รายการ Personและเรียกใช้วิธีการพิมพ์ได้ดังนี้:

Person person = new Person("John", 30);
person.print();

สิ่งนี้จะส่งออกName: John, Age: 30ไป ยังคอนโซล ดังที่แสดงในตัวอย่าง เร็กคอร์ด Java สามารถใช้อินเทอร์เฟซได้เหมือนกับคลาสทั่วไป สิ่งนี้มีประโยชน์สำหรับการเพิ่มลักษณะการทำงานให้กับรายการหรือเพื่อให้แน่ใจว่ารายการสอดคล้องกับสัญญาที่กำหนดโดยอินเทอร์เฟซ