streamalism.org

1. סקירה כללית

במאמר זה נדבר על תכונת ליבה של שפת Java - הערות ברירת המחדל הזמינות ב- JDK.

2. מהי ביאור

במילים פשוטות, הערות הן סוגי Java שקדמו להם סמל "@".

ל- Java היו הערות מאז המהדורה 1.5. מאז הם עיצבו את האופן בו תכננו את היישומים שלנו.

Spring and Hibernate הם דוגמאות נהדרות למסגרות הנשענות במידה רבה על ביאורים כדי לאפשר טכניקות עיצוב שונות.

בעיקרון, ביאור מקצה מטא-נתונים נוספים לקוד המקור אליו הוא מחויב. על ידי הוספת הערה לשיטה, ממשק, מחלקה או שדה, אנו יכולים:

1. יידע את המהדר על אזהרות ושגיאות
2. טפל בקוד המקור בזמן האוסף
3. שנה או בחן התנהגות בזמן ריצה

3. הערות מובנות בג'אווה

עכשיו, לאחר שבדקנו את היסודות, בואו נסתכל על כמה הערות המועברות עם Java הליבה. ראשית, ישנם כמה המיידעים אוסף:

1. @Override
2. @SuppressWarnings
3. @ מיושן
4. @ SafeVarargs
5. @FunctionalInterface
6. @יָלִיד

הערות אלה יוצרות או מדכאות אזהרות ושגיאות של מהדר. השימוש בהם באופן עקבי הוא לרוב נוהג טוב מאחר והוספתם יכולה למנוע שגיאות מתכנתים בעתיד.

ה @Override הערה משמשת כדי לציין ששיטה עוקפת או מחליפה את ההתנהגות של שיטה שעברה בירושה.

@SuppressWarnings מציין שאנחנו רוצים להתעלם מאזהרות מסוימות מחלק מהקוד. ה @ SafeVarargs ביאור פועל גם על סוג של אזהרה הקשורה לשימוש ב- varargs.

ה @ מיושן ניתן להשתמש בהערה לסימון API כמי שאינו מיועד לשימוש יותר. יתר על כן, הערה זו שופצה מחדש בג'אווה 9 כדי לייצג מידע נוסף אודות הפחת.

על כל אלה תוכלו למצוא מידע מפורט יותר במאמרים המקושרים.

3.1. @FunctionalInterface

Java 8 מאפשר לנו לכתוב קוד בצורה פונקציונאלית יותר.

ממשקי שיטה מופשטת יחידה הם חלק גדול מזה. אם בכוונתנו להשתמש בממשק SAM על ידי lambdas, אנו יכולים לסמן אותו ככזה עם @FunctionalInterface:

ממשק ציבורי @FunctionalInterface Adder {int add (int a, int b); }

כמו @Override בשיטות, @FunctionalInterface מצהיר על כוונותינו עם פֶּתֶן.

עכשיו, אם נשתמש @FunctionalInterface או לא, אנחנו עדיין יכולים להשתמש פֶּתֶן באותה הדרך:

Adder adder = (a, b) -> a + b; int result = adder.add (4,5);

אבל, אם נוסיף שיטה שנייה ל פֶּתֶן, ואז המהדר יתלונן:

@FunctionalInterface ממשק ציבורי Adder {// מהדר מתלונן כי הממשק אינו תוסף int int (int a, int b); int div (int a, int b); }

עכשיו זה היה מתאסף בלי @FunctionalInterface ביאור. אז מה זה נותן לנו?

כמו @Override, הערה זו מגנה עלינו מפני שגיאות מתכנת עתידיות. למרות שזה חוקי שיש יותר משיטה אחת בממשק, זה לא כאשר ממשק זה משמש כיעד למבדה. ללא ההערה הזו, המהדר היה פורץ בעשרות המקומות שבהם פֶּתֶן שימש למבדה. עַכשָׁיו, זה פשוט פורץ פנימה פֶּתֶן את עצמה.

3.2. @יָלִיד

נכון ל- Java 8, יש הערה חדשה ב- הערה java.lang חבילה שנקראת יָלִיד. ה @יָלִיד ביאור חל רק על שדות. זה מציין ששדה ההערה הוא קבוע שאליו ניתן להפנות מהקוד המקורי. לדוגמה, הנה איך זה משמש ב- מספר שלם מעמד:

כיתת גמר ציבורית שלם {@ גמר סטטי ציבורי מקומי int MIN_VALUE = 0x80000000; // הושמט }

הערה זו יכולה לשמש גם רמז לכלים ליצירת כמה קבצי כותרת עזר.

4. מטא-ביאורים

לאחר מכן, מטא-ביאורים הם הערות שניתן להחיל על הערות אחרות.

לדוגמה, מטה-הערות אלה משמשות לתצורת ההערות:

1. @יַעַד
2. @הַחזָקָה
3. @ירש
4. @מְתוֹעָד
5. @הָדִיר

4.1. @יַעַד

היקף ההערות יכול להשתנות בהתאם לדרישות. בעוד שהערה אחת משמשת רק בשיטות, ניתן לצרוך הערה אחרת באמצעות הצהרות קונסטרוקטור ושדה.

כדי לקבוע את רכיבי היעד של הערה מותאמת אישית, עלינו לסמן אותה עם @יַעַד ביאור.

@יַעַד יכול לעבוד עם שמונה סוגי אלמנטים שונים. אם נסתכל על קוד המקור של @SafeVarargsואז אנו יכולים לראות כי עליו להיות מחובר רק לבונים או לשיטות:

@Documented @Retention (RetentionPolicy.RUNTIME) @Target ({ElementType.CONSTRUCTOR, ElementType.METHOD}) ציבור @ ממשק SafeVarargs {}

4.2. @הַחזָקָה

הערות מסוימות נועדו לשמש רמזים עבור המהדר, בעוד שאחרות משמשות בזמן ריצה.

אנו משתמשים ב- @הַחזָקָה ביאור לומר היכן במחזור החיים של התוכנית שלנו חלה ההערה שלנו.

לשם כך עלינו להגדיר @הַחזָקָה עם אחת משלוש מדיניות שמירה:

1. RetentionPolicy.SOURCE - לא נראה על ידי המהדר ולא זמן הריצה
2. RetentionPolicy.CLASS - גלוי על ידי המהדר
3. RetentionPolicy.RUNTIME - גלוי על ידי המהדר וזמן הריצה

@הַחזָקָה ברירת מחדל ל RetentionPolicy.SOURCE.

אם יש לנו הערה שצריכה להיות נגישה בזמן הריצה:

@Retention (RetentionPolicy.RUNTIME) @Target (TYPE) ציבורי @interface RetentionAnnotation {}

ואז, אם נוסיף כמה הערות לשיעור:

@RetentionAnnotation @ Class class מיושן AnnotatedClass {}

עכשיו אנחנו יכולים להרהר הערה קלאס כדי לראות כמה הערות נשמרות:

@ מבחן ציבורי בטל כאשר AnnotationRetentionPolicyRuntime_shouldAccess () {AnnotatedClass anAnnotatedClass = חדש AnnotatedClass (); ביאור [] הערות = anAnnotatedClass.getClass (). GetAnnotations (); assertThat (הערות.אורך, הוא (1)); }

הערך הוא 1 בגלל @ RetentAnnotation יש מדיניות שימור של זמן זמן בזמן @ מיושן לא.

4.3. @ירש

במצבים מסוימים, ייתכן שנצטרך תת-מחלקה כדי שההערות יהיו קשורות לכיתת הורים.

אנחנו יכולים להשתמש ב- @ירש ביאור בכדי להפוך את ההערה שלנו להפיץ מעמד עם הערות אל מחלקות המשנה שלו.

אם אנו פונים @ירש להערה המותאמת אישית שלנו ואז להחיל אותה על BaseClass:

@Inherited @Target (ElementType.TYPE) @Retention (RetentionPolicy.RUNTIME) ציבורי @interface InheritedAnnotation {} @InheritedAnnotation מחלקה ציבורית BaseClass {} מחלקה ציבורית DerivedClass מרחיב את BaseClass {}

לאחר מכן, לאחר הארכת ה- BaseClass, עלינו לראות זאת DerivedClass נראה שיש אותה הערה בזמן הריצה:

@ מבחן ציבורי בטל כאשר AnnotationInherited_thenShouldExist () {DerivedClass derivClass = New DerivedClass (); הערת InheritedAnnotation = derivatedClass.getClass () .getAnnotation (InheritedAnnotation.class); assertThat (ביאור, instanceOf (InheritedAnnotation.class)); }

בלי ה @ירש ביאור, המבחן הנ"ל ייכשל.

4.4. @מְתוֹעָד

כברירת מחדל, ג'אווה אינה מתעדת את השימוש בהערה ב- Javadocs.

אבל, אנחנו יכולים להשתמש ב- @מְתוֹעָד ביאור לשינוי התנהגות ברירת המחדל של Java.

אם ניצור הערה מותאמת אישית המשתמשת @מְתוֹעָד:

@Documented @Target (ElementType.FIELD) @Retention (RetentionPolicy.RUNTIME) ציבורי @interface ExcelCell {ערך ערך (); }

והחל אותו על אלמנט Java המתאים:

שכיר ציבורי עובד {@ExcelCell (0) שם מחרוזי ציבורי; }

אז ה עוֹבֵד Javadoc יחשוף את השימוש בהערות:

4.5. @הָדִיר

לפעמים זה יכול להיות שימושי לציין את אותה הערה יותר מפעם אחת על אלמנט Java נתון.

לפני Java 7, היינו חייבים לקבץ ביאורים להערת מכולה אחת:

@Schedules ({@Schedule (time = "15:05"), @Schedule (time = "23:00")}) בטל planAlarm () {}

עם זאת, Java 7 הביא גישה נקייה יותר. עם ה @הָדִיר ביאור, אנחנו יכולים להפוך את ההערה לחוזרת:

@ Repeatable (Schedules.class) פומבית @ ממשק לוח זמנים {זמן מחרוזת () ברירת מחדל "09:00"; }

להשתמש @הָדִיר, עלינו לקבל גם הערת מכולה. במקרה זה, נעשה שימוש חוזר @ לוחות זמנים:

לוחות זמנים ממשק @ ציבורי {ערך תזמון [] (); }

כמובן, זה נראה הרבה כמו מה שהיה לנו לפני Java 7. אבל הערך עכשיו הוא העטיפה @ לוחות זמנים לא מוגדר יותר מתי עלינו לחזור @לוח זמנים:

@Schedule @Schedule (time = "15:05") @Schedule (time = "23:00") בטל planAlarm () {}

מכיוון שג'אווה דורשת את הערת העטיפה, היה לנו קל לעבור מרשימות ההערות שלפני Java 7 לרשומות שניתן לחזור עליהן.

5. מסקנה

במאמר זה דיברנו על הערות מובנות בג'אווה שכל מפתח ג'אווה צריך להכיר.

כמו תמיד, ניתן למצוא את כל הדוגמאות של המאמר ב- GitHub.