คำอธิบายโดยละเอียดและรหัสตัวอย่างใน Java

ใน Java มีการแนะนำคำอธิบายประกอบใน Java 5 และใช้เพื่ออธิบายข้อมูลเมตาของรหัส Java โดยปกติแล้วคำอธิบายประกอบจะไม่ส่งผลโดยตรงต่อการดำเนินการของรหัสแม้ว่าคำอธิบายประกอบบางอย่างสามารถใช้เพื่อส่งผลกระทบต่อการดำเนินการของรหัส

สิ่งที่สามารถทำได้ด้วยคำอธิบายประกอบ

คำอธิบายประกอบใน Java มักจะมีบทบาทต่อไปนี้

1. คำสั่งคอมไพเลอร์
2. คำสั่งสร้างเวลา
3. คำแนะนำรันไทม์
   

ใน

1. Java มีคำแนะนำคอมไพเลอร์สามประเภทซึ่งจะมีการแนะนำในภายหลังในบทความนี้
2. สามารถใช้คำอธิบายประกอบ Java ได้ในเวลาสร้างเช่นเมื่อคุณสร้างโครงการของคุณ กระบวนการก่อสร้างรวมถึงการสร้างซอร์สโค้ดการรวบรวมซอร์สโค้ดการสร้างไฟล์ XML ซอร์สโค้ดที่รวบรวมและไฟล์ไปยังแพ็คเกจ JAR ฯลฯ การก่อสร้างซอฟต์แวร์มักจะทำโดยอัตโนมัติโดยใช้เครื่องมือเช่น Apache Ant และ Maven เครื่องมือสร้างเหล่านี้สแกนรหัส Java ตามคำอธิบายประกอบเฉพาะจากนั้นสร้างซอร์สโค้ดหรือไฟล์ตามคำอธิบายประกอบเหล่านี้
3. โดยปกติแล้วคำอธิบายประกอบจะไม่ปรากฏในรหัสที่รวบรวม แต่ก็โอเคถ้าพวกเขาต้องการปรากฏ Java รองรับคำอธิบายประกอบรันไทม์ การใช้ Java Reflection เราสามารถเข้าถึงคำอธิบายประกอบเหล่านี้ได้ จุดประสงค์ของคำอธิบายประกอบรันไทม์มักจะให้คำแนะนำบางอย่างกับโปรแกรมและ API ของบุคคลที่สาม
   

พื้นฐานคำอธิบายประกอบ

คำอธิบายประกอบ Java ง่าย ๆ คล้ายกับ @Entity โดยที่ @ หมายถึงการบอกคอมไพเลอร์ว่านี่เป็นคำอธิบายประกอบ เอนทิตีคือชื่อของคำอธิบายประกอบ โดยปกติในไฟล์วิธีการเขียนมีดังนี้

Public @Interface Entity {
-

องค์ประกอบคำอธิบายประกอบ

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

Public @Interface Entity {
String tablename ();
-

รหัสตัวอย่างโดยใช้คำอธิบายประกอบที่มีองค์ประกอบ

@ENTITY (TABLENAME = "ยานพาหนะ")

ชื่อองค์ประกอบของคำอธิบายประกอบข้างต้นคือชื่อ tablename และชุดค่าคือยานพาหนะ คำอธิบายประกอบที่ไม่มีองค์ประกอบไม่จำเป็นต้องใช้วงเล็บ

หากคำอธิบายประกอบมีองค์ประกอบหลายอย่างวิธีการใช้จะมีดังนี้

@ENTITY (TABLENAME = "ยานพาหนะ", primaryKey = "id")

หากคำอธิบายประกอบมีเพียงองค์ประกอบเดียวเรามักจะเขียนแบบนี้

@insertNew (value = "ใช่")

แต่ในกรณีนี้ถ้าหากชื่อองค์ประกอบคือค่าเรายังสามารถย่อมันได้นั่นคือไม่จำเป็นต้องกรอกค่าชื่อองค์ประกอบผลเป็นดังนี้

@InsertNew ("ใช่")

การใช้คำอธิบายประกอบ

คำอธิบายประกอบสามารถใช้ในการแก้ไของค์ประกอบเหล่านี้ในรหัส

1. ใจดี
2. ส่วนต่อประสาน
3. วิธี
4. พารามิเตอร์วิธีการ
5. คุณสมบัติ
6. ตัวแปรท้องถิ่น
   

ตัวอย่างการใช้งานที่สมบูรณ์มีดังนี้

 @EntityPublic Class Vehicle {@Persistent String String VehicLename = NULL; @getter สตริงสาธารณะ getvehiclename () {return this.vehiclename; } โมฆะสาธารณะ setvehiclename (@Optional Vehiclename) {this.vehiclename = ยานพาหนะ; } รายการสาธารณะ addvehiclenametolist (ชื่อรายการ) {@optional list localNames = ชื่อ; if (localNames == null) {localNames = new ArrayList (); } localNames.add (getvehiclename ()); คืนชื่อ localname; -

คำอธิบายประกอบ Java ในตัว

มีคำอธิบายประกอบในตัวสามตัวใน Java ที่ใช้เพื่อให้คำแนะนำสำหรับคอมไพเลอร์ พวกเขาคือ

1. @deprecated
2. @Override
3. @suppresswarnings
   

@deprecated

สามารถใช้เพื่อทำเครื่องหมายคลาสวิธีการและคุณสมบัติ
หากไม่มีการใช้องค์ประกอบสามอย่างข้างต้นให้ใช้คำอธิบายประกอบ @deprecated หากรหัสใช้คลาสวิธีการหรือคุณสมบัติของคำอธิบายประกอบ @Deprecated คอมไพเลอร์จะเตือนคุณ

@Deprecated ใช้งานง่ายมากดังนี้: คำอธิบายประกอบของคลาสที่เลิกเรียน

 @DepreCatedPublic คลาส MyComponent {}

เมื่อเราใช้คำอธิบายประกอบ @Deprecated ขอแนะนำให้ใช้สัญลักษณ์ @Deprecated Javadoc ที่เกี่ยวข้องร่วมกับมันและอธิบายว่าทำไมคลาสวิธีการหรือคุณสมบัตินี้จึงเลิกใช้และอะไรคือทางเลือก

 @Deprecated/** @Deprecated คลาสนี้เต็มไปด้วยข้อบกพร่อง ใช้ myNewComponent แทน*/คลาสสาธารณะ myComponent {}

@Override

คำอธิบายประกอบ @Override ใช้เพื่อแก้ไขวิธีการเขียนคลาสแม่ใหม่ หากวิธีการที่ไม่ได้แทนที่คลาสพาเรนต์ใช้คำอธิบายประกอบนี้คอมไพเลอร์จะแจ้งข้อผิดพลาด

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

ตัวอย่างของการใช้คำอธิบายประกอบการแทนที่

 คลาสสาธารณะ mysuperclass {โมฆะสาธารณะ dothething () {system.out.println ("ทำสิ่ง"); }} คลาสสาธารณะ MySubClass ขยาย MySuperClass {@Override โมฆะสาธารณะ dothething () {system.out.println ("ทำแตกต่างกัน"); -

@suppresswarnings

@suppresswarnings ใช้เพื่อปราบปรามคอมไพเลอร์จากการสร้างข้อความเตือน

องค์ประกอบที่สามารถแก้ไขได้คือคลาสวิธีการพารามิเตอร์วิธีการคุณลักษณะและตัวแปรท้องถิ่น

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

@suppresswarnings คำอธิบายประกอบเพื่อระงับคำเตือนการสร้างคอมไพเลอร์

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

ตัวอย่างการใช้งาน

 @suppresswarningspublic moid methodwithwarning () {}

สร้างคำอธิบายประกอบของคุณเอง

ใน Java เราสามารถสร้างคำอธิบายประกอบคำอธิบายประกอบและคลาสของเราเองและไฟล์อินเทอร์เฟซถูกกำหนดไว้ในไฟล์ของเราเอง ดังนี้

 @Interface myannotation {ค่าสตริง (); ชื่อสตริง (); อายุ int (); สตริง [] newNames ();}

รหัสข้างต้นกำหนดคำอธิบายประกอบที่เรียกว่า myannotation ซึ่งมี 4 องค์ประกอบ อีกครั้งคำหลัก @Interface ใช้เพื่อบอกคอมไพเลอร์ Java ว่านี่เป็นคำอธิบายประกอบ

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

1. ชนิดข้อมูลดั้งเดิม
2. สาย
3. ระดับ
4. คำอธิบายประกอบ
5. แจกแจง
6. อาร์เรย์หนึ่งมิติ
   

ต่อไปนี้เป็นคำอธิบายประกอบที่กำหนดเองของแอพ

 @myannotation (value = "123", name = "jakob", อายุ = 37, newNames = {"Jenkov", "Peterson"}) คลาสสาธารณะ myclass {}

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

ค่าเริ่มต้นองค์ประกอบค่าเริ่มต้น

สำหรับองค์ประกอบในคำอธิบายประกอบเราสามารถตั้งค่าเริ่มต้นสำหรับพวกเขาโดยใช้วิธีการ

 @Interface myannotation {ค่าสตริง () ค่าเริ่มต้น ""; ชื่อสตริง (); อายุ int (); สตริง [] newNames ();}

ในรหัสข้างต้นเราตั้งค่าเริ่มต้นขององค์ประกอบค่าเป็นสตริงว่าง เมื่อเราใช้มันเราไม่สามารถตั้งค่าได้นั่นคือปล่อยให้ค่าใช้ค่าเริ่มต้นของสตริงว่าง ใช้รหัสตัวอย่าง

 @myannotation (name = "jakob", อายุ = 37, newNames = {"Jenkov", "Peterson"}) คลาสสาธารณะ myclass {}

@retention

@retention เป็นคำอธิบายประกอบที่ใช้ในการแก้ไขคำอธิบายประกอบ การใช้คำอธิบายประกอบนี้เราสามารถทำได้

ควบคุมว่าคำอธิบายประกอบถูกเขียนลงในไฟล์คลาสเพื่อควบคุมว่ามีคำอธิบายประกอบในไฟล์คลาสหรือไม่

การควบคุมเป็นเรื่องง่ายเพียงใช้หนึ่งในสามกลยุทธ์ต่อไปนี้

RetentionPolicy.Source ระบุว่าคำอธิบายประกอบมีอยู่ในซอร์สโค้ดเท่านั้นไม่มีไฟล์คลาสและไม่สามารถมองเห็นได้ในระหว่างการรันไทม์ คำอธิบายประกอบทั่วไปคือ @Override, @SuppressWarnings
RetentionPolicy.class นี่เป็นนโยบายการเก็บรักษาคำอธิบายประกอบเริ่มต้น ภายใต้กลยุทธ์นี้คำอธิบายประกอบจะมีอยู่กับไฟล์. class แต่ไม่สามารถเข้าถึงได้ที่รันไทม์ โดยปกติแล้วกลยุทธ์คำอธิบายประกอบนี้จะใช้ในการทำงานในระดับไบต์บางระดับ
RetentionPolicy.runtime สามารถเข้าถึงได้ที่รันไทม์ภายใต้นโยบายนี้ บ่อยครั้งที่เราทำอะไรบางอย่างร่วมกับการสะท้อน

ตัวอย่างการใช้ @retention

 นำเข้า java.lang.annotation.retention; นำเข้า java.lang.annotation.retentionPolicy; @retention

@เป้า

การใช้คำอธิบายประกอบ @Target เราสามารถตั้งค่าองค์ประกอบ Java ที่สามารถแก้ไขได้ด้วยคำอธิบายประกอบที่กำหนดเอง ตัวอย่างง่ายๆ

 นำเข้า java.lang.annotation.elementtype; นำเข้า java.lang.annotation.target; @Target ({ElementType.Method}) สาธารณะ @interface myannotation {ค่าสตริง ();};

รหัสด้านบนแสดงให้เห็นว่าคำอธิบายประกอบ myannotation สามารถแก้ไขวิธีการเท่านั้น

@Target สามารถเลือกค่าพารามิเตอร์ได้ดังนี้

1. ElementType.annotation_type (หมายเหตุ: แก้ไขหมายเหตุ)
2. ElementType.Constructor
3. ElementType.field
4. ElementType.local_Variable
5. ElementType.method
6. ElementType.package
7. ElementType.Parameter
8. ElementType.type (หมายเหตุ: ประเภทใด ๆ นั่นคือประเภทด้านบนสามารถแก้ไขได้)
   

@inherited

หากคุณต้องการคลาสและคลาสย่อยของการมีคำอธิบายประกอบคุณสามารถใช้ @inherited เพื่อแก้ไขคำอธิบายประกอบนี้

 java.lang.annotation.inherited@inheritedpublic @interface myannotation {} 12@myannotationpublic คลาส mysuperclass {... } 1public คลาส mysubclass ขยาย mysuperclass {... }}

ความหมายทั่วไปของรหัสข้างต้นคือ

1. ใช้ @inherited เพื่อแก้ไขคำอธิบายประกอบ
2. คำอธิบายประกอบของ mysuperclass โดยใช้ myannotation
3. ใช้คลาส mysubclass คลาสที่สืบทอดมาจาก mysuperclass

ผ่านขั้นตอนข้างต้น MySubClass ยังมีคำอธิบายประกอบ myannotation

นี่คือแนวคิดพื้นฐานบางประการเกี่ยวกับคำอธิบายประกอบใน Java

ข้างต้นคือการเรียงลำดับของคำอธิบายประกอบใน Java เราจะยังคงเพิ่มข้อมูลที่เกี่ยวข้องในอนาคต ขอบคุณสำหรับการสนับสนุนเว็บไซต์นี้!