ממשקי סמן ב- Java

1. הקדמה

במדריך מהיר זה נלמד על ממשקי סמן ב- Java.

2. ממשקי סמן

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

ממשק סמן נקרא גם ממשק תיוג.

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

3. ממשקי סמן JDK

ל- Java יש ממשקי סמן מובנים רבים, כגון ניתן לבצע סדרתי, ניתנת לשיבוט, ו מְרוּחָק.

ניקח את הדוגמה של ה- ניתנת לשיבוט מִמְשָׁק. אם ננסה לשכפל אובייקט שאינו מיישם ממשק זה, ה- JVM זורק א CloneNotSupportedException. מכאן, ש ניתנת לשיבוטממשק סמן הוא אינדיקטור ל- JVM שנוכל לקרוא Object.clone () שיטה.

באותו אופן, כאשר מתקשרים ל ObjectOutputStream.writeObject () שיטה, ה- JVM בודק אם האובייקט מיישם את ניתן לבצע סדרתי ממשק סמן. כשזה לא המקרה, א NotSerializableException נזרק. לכן, האובייקט אינו מסודר לזרם הפלט.

4. ממשק סמן מותאם אישית

בואו ניצור ממשק סמן משלנו.

לדוגמה, נוכל ליצור סמן המציין אם ניתן להסיר אובייקט ממסד הנתונים:

ממשק ציבורי ניתן למחיקה {}

על מנת למחוק ישות ממסד הנתונים, האובייקט המייצג ישות זו צריך ליישם את היישות שלנו ניתן למחיקה ממשק סמן:

יישויות מחלקה ציבורית מיישמת מחיקה {// פרטי יישום}

נניח שיש לנו אובייקט DAO עם שיטה להסרת ישויות ממסד הנתונים. אנחנו יכולים לכתוב את שלנו לִמְחוֹק() שיטה כך רק אובייקטים המיישמים את ממשק הסמן שלנו ניתן למחוק:

מחלקה ציבורית ShapeDao {// שיטות דאו אחרות מחיקה בוליאנית ציבורית (אובייקט אובייקט) {אם (! (מופע של אובייקט מחיקה)) {return false; } // מחק פרטי יישום מחזירים נכון; }}

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

5. ממשקי סמן לעומת הערות

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

אז מה ההבדל העיקרי?

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

לדוגמא, בואו להוסיף מגבלה שרק א צוּרָה ניתן להסיר את סוג הנתונים ממסד הנתונים:

ממשק ציבורי צורה {כפול getArea (); כפול getCircumference (); }

במקרה זה, ממשק הסמן שלנו, בואו נקרא לזה DeletableShape, ייראה כך:

ממשק ציבורי DeletableShape מרחיב צורה {}

אז המחלקה שלנו תיישם את ממשק הסמנים:

יישומי מלבן ממחלקה ציבורית DeletableShape {// פרטי יישום}

לָכֵן, את כל DeletableShape יישומים הם גם צוּרָה יישומים. מובן מאליו, איננו יכולים לעשות זאת באמצעות הערות.

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

6. ממשקי סמן לעומת ממשקים אופייניים

בדוגמה הקודמת, נוכל להשיג את אותן התוצאות על ידי שינוי ה- DAO שלנו לִמְחוֹק() שיטה לבדוק אם האובייקט שלנו הוא a צוּרָה או שלא, במקום לבדוק אם זה א מחיקה:

מחלקה ציבורית ShapeDao {// שיטות אחרות של dao delete בוליאני ציבורי (אובייקט אובייקט) {if (! (object instanceof Shape)) {return false; } // מחק פרטי יישום מחזירים נכון; }}

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

בואו נדמיין את זה, בנוסף ל צוּרָה סוג, אנו רוצים להסיר את אדם הקלד גם ממסד הנתונים. במקרה זה, ישנן שתי אפשרויות להשיג זאת:

האפשרות הראשונה היא להוסיף צ'ק נוסף לקודם שלנו לִמְחוֹק() שיטה כדי לוודא אם האובייקט למחוק הוא מופע של אדם או שלא.

מחיקה בוליאנית ציבורית (אובייקט אובייקט) {if (! (אובייקט מופע של צורה || מופע אובייקט של אדם)) {return false; } // מחק פרטי יישום מחזירים נכון; }

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

האפשרות השנייה היא לעשותה אדם סוג ליישם את צוּרָה מִמְשָׁק, המשמש כממשק סמן. אבל האם הוא אדם אובייקט באמת א צוּרָה? התשובה היא בבירור לא, וזה הופך את האפשרות השנייה לגרועה יותר מהאחת.

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

7. מסקנה

במאמר זה דנו במה הם ממשקי סמן וכיצד ניתן להשתמש בהם. ואז בדקנו כמה דוגמאות מובנות של Java לממשקים מסוג זה וכיצד הם משמשים את JDK.

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

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