ממשקי Java

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

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

2. מהם ממשקים בג'אווה?

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

בואו נראה דוגמה פשוטה לממשק ב- Java:

ממשק ציבורי אלקטרוני {// קבוע משתנה מחרוזת LED = "LED"; // שיטה מופשטת int getElectricityUse (); // שיטה סטטית בוליאנית סטטית isEnergyEfficient (String electtronicType) {if (electtronicType.equals (LED)) {return true; } להחזיר שקר; } // ברירת המחדל של שיטת ברירת המחדל בטלה printDescription () {System.out.println ("תיאור אלקטרוני"); }} 

אנו יכולים ליישם ממשק בשיעור Java באמצעות ה- מכשירים מילת מפתח.

לאחר מכן, בואו ניצור גם מַחשֵׁב כיתה המיישמת את אֶלֶקטרוֹנִי ממשק שיצרנו זה עתה:

מחלקה ציבורית מיישמת מחשבים אלקטרונית {@Override public int getElectricityUse () {return 1000; }} 

2.1. כללים ליצירת ממשקים

בממשק אנו רשאים להשתמש ב:

  • משתנים קבועים
  • שיטות מופשטות
  • שיטות סטטיות
  • שיטות ברירת מחדל

עלינו לזכור כי:

  • אנחנו לא יכולים ליצור ממשקים באופן ישיר
  • ממשק יכול להיות ריק, ללא שיטות או משתנים בו
  • אנחנו לא יכולים להשתמש ב- סופי מילה בהגדרת הממשק, מכיוון שהיא תביא לשגיאת מהדר
  • כל הצהרות הממשק צריכות להכיל את פּוּמְבֵּי או משנה גישה ברירת מחדל; ה תַקצִיר השינוי יתווסף אוטומטית על ידי המהדר
  • שיטת ממשק לא יכולה להיות פְּרָטִי, מוּגָן, או סופי
  • משתני ממשק הם פּוּמְבֵּי, סטָטִי, ו סופי לפי הגדרה; אסור לנו לשנות את הנראות שלהם

3. מה נוכל להשיג באמצעותם?

3.1. פונקציונליות התנהגותית

אנו משתמשים בממשקים כדי להוסיף פונקציונליות התנהגותית מסוימת שיכולה לשמש כיתות שאינן קשורות. לדוגמה, ניתן להשוות, משווה, ו ניתנת לשיבוט הם ממשקי Java שניתן ליישם על ידי כיתות שאינן קשורות. להלן דוגמה ל משווה מִמְשָׁקהמשמש להשוואה בין שני מקרים של עוֹבֵד מעמד:

עובד שכבה ציבורית {שכר כפול פרטי; כפול ציבורי getSalary () {משכורת תמורה; } בטל פומבי setSalary (שכר כפול) {this.salary = משכורת; }} EmployeeSalaryComparator ממחוז ציבורי מיישם את Comparator {@Override public int השווה (עובד עובד א, עובד עובד ב) {אם (עובד A. getSalary () עובד B.getSalary ()) {תשואה 1; } אחר {להחזיר 0; }}} 

למידע נוסף, אנא בקרו במדריך שלנו בנושא משווה ו ניתן להשוות בג'אווה.

3.2. מספר ירושות

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

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

ממשק ציבורי Transform {void transform (); } ממשק ציבורי טוס {void fly (); } יישומי רכב בכיתה ציבורית Fly, Transform {@Override fly void fly () {System.out.println ("I can Fly !!"); } @Override public void transform () {System.out.println ("I can Transform !!"); }} 

3.3. רב צורתיות

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

בג'אווה נוכל להשיג פולימורפיזם באמצעות ממשקים. לדוגמא, ה צוּרָה ממשק יכול ללבוש צורות שונות - זה יכול להיות מעגל או א כיכר.

נתחיל בהגדרת ה- צוּרָה מִמְשָׁק:

ממשק ציבורי צורה {שם מחרוזת (); } 

עכשיו בואו גם ליצור את מעגל מעמד:

מחלקה ציבורית מעגל מיישם צורה {@ השג ציבורי שם מחרוזת () {החזר "מעגל"; }} 

וגם ה כיכר מעמד:

מחלקה ציבורית מיישמת כיכר צורה {@Override public שם מחרוזת () {להחזיר "כיכר"; }} 

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

צורות רשימה = ArrayList חדש (); צורה מעגל צורה = מעגל חדש (); צורה מרובעת צורה = ריבוע חדש (); צורות. להוסיף (עיגול צורה); צורות. להוסיף (מרובע צורה); עבור (צורת צורה: צורות) {System.out.println (צורה.שם ()); } 

4. שיטות ברירת מחדל בממשקים

ממשקים מסורתיים ב- Java 7 ומטה אינם מציעים תאימות לאחור.

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

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

5. כללי ירושה בממשק

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

5.1. ממשק הרחבת ממשק אחר

כאשר ממשק מרחיב ממשק אחר, הוא יורש את כל השיטות המופשטות של הממשק הזה. נתחיל ביצירת שני ממשקים, HasColor ו צוּרָה:

ממשק ציבורי HasColor {String getColor (); } ממשק ציבורי Box מרחיב את HasColor {int getHeight ()} 

בדוגמה לעיל, קופסא יורש מ HasColor באמצעות מילת המפתח מרחיב. על ידי כך, ה קופסא ממשק יורש getColor. כתוצאה מכך, קופסא לממשק יש כעת שתי שיטות: getColor ו getHeight.

5.2. כיתה מופשטת יישום ממשק

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

ממשק ציבורי Transform {void transform (); ריק ברירת מחדל printSpecs () {System.out.println ("מפרט שינוי"); }} מחלקה מופשטת ציבורית בכלי רכב טרנספורמציה {} 

בדוגמה זו, רכב הכיתה יורשת שתי שיטות: המופשט שינוי צורה שיטת ברירת המחדל printSpecs שיטה.

6. ממשקים פונקציונליים

לג'אווה היו ממשקים פונקציונליים רבים מאז ימיה הראשונים, כגון ניתן להשוות (מאז Java 1.2) ו- ניתן לרוץ (מאז Java 1.0).

Java 8 הציגה ממשקים פונקציונליים חדשים כגון לְבַסֵס, צרכן, ו פוּנקצִיָה. למידע נוסף על אלה, אנא בקרו במדריך שלנו בנושא ממשקים פונקציונליים ב- Java 8.

7. מסקנה

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

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