ממשק - Interface בתכנות מונחה עצמים
interface): טיפוס שמכיל הצהרות בלבד על יכולות, שמחלקה יכולה לממש בלי הגבלה.public מטבעם.struct יכול לממש אינטרפייסים.IDisposable עם הפונקציה Dispose, מי שמשתמש בה יודע שהפונקציה נועדה לשחרר משאבים.I, למשל IPlayer.DVD ממש את IPlayer עם Play, Pause, Stop, Forward ו-Backward. הקומפיילר מציג שגיאות עד שכל הפונקציות ממומשות.Ctrl+., ואז בוחרים את האפשרות ליצור את המימוש.Toaster ו-DVD יורשים את ElectronicDevice, אבל רק DVD ממש את IPlayer. לכן לפני קריאה ל-Play בודקים אם האובייקט הוא IPlayer בעזרת is או as, ולא אם הוא DVD. כך אפשר להגדיר יכולת משותפת לכמה מחלקות שונות, ולדעת שהפונקציות שלה קיימות בכל אחת מהן.פרקי ההרצאה: ממשק - Interface בתכנות מונחה עצמים
תמלול ההרצאה: ממשק - Interface בתכנות מונחה עצמים
הטקסט המלא של הדקות הראשונות בהרצאה «ממשק - Interface בתכנות מונחה עצמים» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
אנחנו מגיעים לכלי חשוב נוסף שקיים באובג'קט אוריינטד וזה האינטרפייס. אינטרפייס הכוונה כאן זה לא לממשק משתמש כמו טפסים וחלונות או אתר אינטרנט, אלא למילה שמורה שנקראת אינטרפייס, היא שייכת לעולם האובג'קט אוריינטד ואנחנו כבר הולכים לראות מה התפקיד שלה.
אנחנו ראינו שבאובג'קט אוריינטד יש בעצם אינקפסוליישן, יש הורשה, יש פולימורפיזם, שלושת אבני הבניין של Object Oriented בנוסף יש כל מיני פקודות וכלים נלווים לשפה עצמה לדוגמה ראינו את Abstract כעת אנחנו מגיעים לאינטרפייס שזה גם כן כלי נוסף ששייך לעולם ה-Object Oriented אז בואו נסתכל קודם כל מה זה
ואז נראה דוגמה אינטרפייס זה מילה שמורה שמאפשרת ליצור טיפוס נתונים שמכיל רק הצהרות על פונקציות תכף נראה בדיוק מה עוד יש שמה אבל הוא מכיל הצהרות על פונקציות.
עכשיו בואו נזכר שהצהרה על פונקציה זה משהו שראינו בעולם האבסטרקטיות כאשר אנחנו בנינו פונקציה אבסטרקטית ואז בעצם הגדרנו רק הצהרה.
אז אם נזכר מה זה בדיוק אומר זה אומר שיש לנו רק הצהרה על פונקציה עם כמובן שם, פרמטרים שהפונקציה מקבלת וערך מוחזר ואז מחלקה שיורשת את המחלקה האבסטרקטית שבנינו הייתה חייבת לתת מימוש לפונקציה האבסטרקטית שהגיעה אליה, שהיא ירשה.
אז זה מאוד דומה לקונספט הזה. גם כאן יש הצהרה על פונקציה בתוך אינטרפייס. המטרה של אינטרפייס זה לתאר יכולת מסוימת, כי תחשבו רגע, מה זה אומר שיש לי ישות כזאת שמכילה רק הצהרות על פונקציות?
מה זה פונקציה? פונקציה זה פעילות. אז אם יש לי כמה פונקציות אז יש לי בעצם סוג של פעילות מסוימת. אז אם יש לי כמה הצהרות על פונקציות זה אומר שאני מתאר פעילות מסוימת שמישהו עכשיו יכול לרשת וליישם.
זאת אומרת קלאס יכולה לרשת אינטרפייס ואז היא תהיה חייבת לממש את כל הפונקציות ההצהרתיות האלה שהגיעו מהאינטרפייס וזה אומר שכעת יש לה את היכולת הזאת.
כנ"ל סטראקט, אמסטראקט יכול לרשת אינטרפייס ולתת מימוש לפונקציות שלו. אינטרפייס לא יכול להכיל דאטה ממברס, כלומר משתנים.
אינטרפייס לא יכול להכיל מימוש לפונקציות, לא ניתן לכתוב פונקציה עם תוכן, רק הצהרות. אינטרפייס יכול להכיל הצהרות על פרופרטיז, כי אני מזכיר לכם שפרופרטי בעצם זה אחת או שתי פונקציות, גט וסט, או רק גט או רק סט.
אז בגלל שזה מעין הצהרות על פונקציות, או בגלל שproperties זה פונקציות, כמובן אינטרפייס יכול להכיל הצהרות על פרופרטיז בלבד.
אינטרפייס יכול להכיל הצהרות על איבנטים, בהמשך אנחנו נראה מה זה איבנט. מחלקה יכולה בדוטנט לרשת מחלקה אחת בלבד, אבל היא יכולה לממש אינטרפייסים בלי הגבלה. כשאנחנו אומרים לממש אנחנו מתכוונים למחלקה שיורשת אינטרפייס ופשוט כותבת תוכן עבור אותן פונקציות או פרופרטיז שהיו בתוך האינטרפייס וגם סטראקט יכול לממש מספר
בלתי מוגבל של אינטרפייסים אז בואו נסתכל על עץ הורשה שאמור להיות במציאות אם אנחנו מסתכלים על עץ הורשה כנראה שהמחלקה הראשונה בעץ תהיה מחלקה אבסטרקטית כי היא נמצאת שם רק בכדי להוות בסיס עבור כל העץ לא בכדי שניצור ממנה אובייקט עכשיו אנחנו בונים את
כל העץ וכל מיני מחלקות הולכות לרשת את המחלקה האבסטרקטית. כאן אנחנו רואים שהמחלקות בסגול נקראות Concrete Class. קונקריט זו מחלקה אמיתית שניתן לבנות ממנה אובייקט, כלומר היא לא אבסטרקטית.
בירוק אנחנו רואים המחלקות אבסטרקטיות, שמהן לא ניתן לבנות אובייקט והמטרה שלהן זה רק להוות בסיס למחלקות אחרות. עכשיו, שימו לב שמחלקה אבסטרקטית יכולה כמובן גם לרשת מחלקה אבסטרקטית אחרת אז יש לנו פה עץ הורשה של מחלקות בנוסף לזה שמחלקה כלשהי יכולה לרשת מחלקה אחרת היא יכולה לממש מספר בלתי מוגבל של ממשקים
כאן אנחנו רואים שיש לנו כל מיני מחלקות שיכולות לרשת אפס ממשקים לא לרשת בכלל לרשת ממשק אחד או יותר ואז בעצם יש לנו פעילויות שהמחלקה צריכה לממש שמגיעות מאינטרפייס מאותה ישות שרק מגדירה מהן הפעילויות שצריכות להיות עבור מחלקה כלשהי. אז השאלה הנשאלת היא למה אנחנו צריכים לקבל את
הפעילויות האלה או את ההצהרות עליהן מממשק תאשר הממשק לא נותן לנו את התוכן ואנחנו צריכים לממש את התוכן בעצמנו. למה פשוט לא לכתוב את התוכן של הפונקציות או את הפונקציות עצמן בלי לרשת אינטרפייס.
ויש לזה כמה שיטות, כמה סיבות. סיבה אחת, אם פעילות מסוימת בנויה ממספר פעילויות, אוקיי, יש איזו יכולת מסוימת ליתר דיוק של אינטרפייס והיא בנויה ממספר פעילויות, אנחנו לא שוכחים שום פעילות ביכולת הזאת.
ניקח דוגמה, אנחנו רוצים לבנות איזושהי מחלקה שהיא תהיה לדוגמה אוסף של פריטים. אוסף של פריטים בעצם זה ישות שמכילה כמה פעילויות בנוגע לאוסף.
לדוגמה פעילות לנקות את כל האוסף, פעילות להוסיף פריט לאוסף, פעילות למחוק פריט מהאוסף. כלומר אם אנחנו רוצים איזושהי מחלקה שתתאר אוסף של פריטים מה שנקרא קולקשן, אולי כדאי שלא נשכח שום פעילות שכלולה בלהיות קולקשן ולכן עדיף שיהיה לנו איזשהו אינטרפייס שיגדיר את כל הפעילויות
שאנחנו צריכים לממש בכדי שאנחנו נהיה קולקשן. ברגע שהגדרנו את האינטרפייס הזה, עכשיו אנחנו יכולים ללכת ולבנות הרבה מחלקות שהן מהוות קולקשן.
אוסף של ספרים, אוסף של סרטים, אוסף של עובדים, אוסף של מטלות, איזה אוסף שאנחנו רוצים, ואנחנו לא נשכח אף פעילות באוסף כי כל הפעילויות באות מאינטרפייס.
סיבה שנייה זה שאם פעילות מסוימת מגיעה מאינטרפייס, אז מחלקה אחרת יכולה לדעת שהפעילות הזאת שייכת לאינטרפייס הספציפי שזה הגיע ממנו ולכן היא יכולה לדעת בדיוק מה מהווה הפעילות.
לדוגמה אם יש פעילות שנקראת dispose שהתפקיד שלה זה לשחרר כל מיני משאבים מהמחלקה אנחנו יכולים שהפעילות הזאת תגיע מאיזשהו אינטרפייס כך שמחלקות אחרות שמשתמשות עם אובייקטים מהמחלקה שלנו יכולות לבדוק האם קיימת לנו פונקציה dispose שהגיעה מאותו אינטרפייס.
אם כן אז הן יודעות בדיוק מה המטרה של הפונקציה dispose ויודעות שזאת לא סתם פונקציה שמציירת משהו על המסך ובמקרה רצינו לקרוא לה dispose או שהיא עושה משהו אחר ורצינו לקרוא לה dispose אם היא הגיעה מהאינטרפייס אז הייעוד שלה ידוע לכל העולם.
למעשה מילה נרדפת לאינטרפייס בעולם פיתוח התוכנה זה קונטרקט, חוזה בין מחלקות. תחשבו על מצב שבו אתם יורשים במחלקה שלכם אינטרפייס, אתם נדרשים עכשיו על פי החוזה הזה לממש את כל הפונקציות שהגיעו מהאינטרפייס.
זה אומר שעכשיו מי שמשתמש במחלקה שלכם ורואה שירשתם את האינטרפייס הזה, אז לפי ה-contract הוא יודע שחייבות להיות לכם הפונקציות האלה, ולא רק שהן חייבות להיות לכם, הוא גם יודע בדיוק מה הן אמורות לעשות.
לדוגמה, dispose אמורה לשחרר משאבים ולא סתם להדפיס משהו על המסך. אוקיי, אז בואו ניכנס לקוד ונראה איך אנחנו עושים את זה.
אז יש לנו כרגע פרויקט ואנחנו עכשיו רוצים לבנות איזשהו עץ פורשה עבור כל מיני מחלקות שיתארו רכיבים חשמליים, רכיבים אלקטרוניים.
לכן כנראה שהולכת להיות לנו איזושהי מחלקת בסיס, ונקרא לה Electronic Device, והיא תהווה מחלקת בסיס עבור כל המחלקות שמתארות רכיבים אלקטרוניים שלנו.
כמובן שהגיוני שהיא תהיה אבסטרקטית. נגדיר פה איזשהו יצרן, נגדיר פה איזשהו דגם, ניקח קונסטרקטור ריק, ניקח קונסטרקטור שמקבל דגם ויצרן, וניקח איזושהי פונקציה שתציג לנו את הפרטים על המסך.
אוקיי, פה סיימנו לבנות את המחלקה שמתארת לנו איזשהו רכיב חשמלי כלשהו. כעת בתוכנה שאנחנו בונים בוא נניח שהיא באה לשרת מעבדה לתיקון מוצרים חשמליים, ובמעבדה הזאת יש גם טוסטרים.
טוסטר הוא גם רכיב חשמלי, יש לו דגם ויצרן, לכן אנחנו יורשים את Electronic Device. טוסטר כמובן היא לא אבסטרטית, מפני שזו ישות אמיתית שקיימת בעולם. אנחנו רוצים רק להוסיף לה איזשהו משתנה.
בואו נניח שאנחנו מוסיפים לה Max Heat, כלומר החום המקסימלי שהטוסטר יכול להכיל. נבנה פה איזשהו C-Tor, אחד שמקבל את כל הפרמטרים, אנחנו יכולים אפילו להגיק את אלה מפה, ולהוסיף Max Heat.
נשלח את המניפקטור ואת המודל, נבנה פרינט, קרא לבייס ונציג maxheat וסיימנו לבנות את המחלקה שמתארת טוסטר.
בואו נעתיק את כל המחלקה הזאת כדי שיהיה פשוט ונבנה עוד מחלקה שקיימת לנו במעבדה והיא מתארת DVD. בואו נשנה כאן את מה שצריך ל-DVD, יש לנו פה קונסטרקטור, ל-DVD יש משתנה בולעני שנקרא can read non-original disk.
אם הוא קורא צרובים כן או לא וסיימנו לבנות העץ הראשה שלנו שבנוי ממחלקת בסיס אבסטרקטית אלקטרוניק דיווייס מחלקה טוסטר ומחלקה dvd כעת בוא נניח שיש לנו כל מיני מחלקות בדוט נט בכלל שהן מתארות כל מיני נגנים נגני וידאו נגני dvd נגנים של רדיו כל מיני נגנים ולכן קיים איזה שהוא אינטרפייס או הגיוני שנרצה שיהיה איזשהו אינטרפייס שמתאר את היכולת הדרושה לנגן.
עכשיו בואו נחשוב אם יש לנו ישות שהיא נגן וידאו או כל נגן שהוא איזה יכולת הגיונית שיהיה לנו צריך שיהיה לנו את היכולת לבצע פליי ואת היכולת לבצע סטופ ואת היכולת לבצע פאוז ואולי להעביר קדימה ואולי להעביר אחורה וכל מיני פונקציות שבכללותן מגדירות שיש לנו יכולת להיות נגן.
אז אנחנו עכשיו רוצים שהיכולת הזאת בעצם תגיע מאיזשהו אינטרפייס. אנחנו יכולים לגשת לפרויקט שלנו ואנחנו יכולים לצרף New Item ולבחור לא Class אלא Interface.
אנחנו רואים את זה פה. לפי מוסכמה נהוג שאינטרפייס יתחיל ב-I גדולה ואז השם. אם אנחנו אגן וידאו אז השם של האינטרפייס יהיה I Layer ואנחנו רואים שפשוט לבנות אינטרפייס מאוד דומה לבנייה של קלאס.
את המילה אינטרפייס ואת השם של הקלאס. שימו לב שהשם של האינטרפייס הוא גם כן בטורקיז ולכן זה טיפוס נתונים. אז אינטרפייס אחת מהחמש מילים שמורות שדיברנו עליהן בעבר שיוצרות טיפוס נתונים שממנו אחר כך אפשר לפתוח איזשהו משתנה.
בתוך האינטרפייס אנחנו מגדירים איזה יכולות אנחנו רוצים שיהיו לנו. לדוגמה את היכולת לבצע פליי. אין שום הרשאת גישה שנותנים ליכולות האלה. כל הפונקציות שמגדירים בתוך האינטרפייס, אין להן שום הרשאת גישה, מהסיבה שאוטומטית כולן הן פאבליק.
המטרה של הפונקציות האלה זה לתאר יכולת שנחשפת החוצה כיכולת ציבורית פאבליק. אין להם כמובן גם מימוש, יש לנו פליי, יש לנו פאוז, יש לנו סטופ, יש לנו forward, אוויר קדימה, ויש לנו backward, האוויר אחורה.
כעת אנחנו רוצים להשתמש עם הטיפוס נתונים החדש שבנינו. מה עושים עם אינטרפייס? כמובן יורשים אותו. בואו נשים אותו פה בצד, ורטיקל, ואנחנו רוצים לרשת אותו כמובן ב-DVD ולא באלקטרוניק דיווייס, כי לא כל האלקטרוניק דיווייס הם נגנים, וכמובן גם לא בטוסטר כי טוסטר הוא לא נגן.
איך עושים את זה? מחלקה יכולה לרשת מחלקה אחת כמו שאנחנו רואים כאן, ובעזרת פסיק אנחנו יכולים להמשיך ולרשת אינטרפייסים.
כמובן שהשם המקצועי זה לא לרשת אינטרפייס אלא לממש אינטרפייס. אבל זה רק סמנטיקה, פחות חשוב לנו. אנחנו מממשים אינטרפייס וברגע שעשינו את זה אנחנו חייבים על פי קונטרקט, על פי חוזה לתת או לבנות את כל הפונקציות שהוגדרו בתוך האינטרפייס.
אם אני אריץ עכשיו קומפילציה אני אחטוף הרבה שגיאות על המחלקה DVD. בואו נסתכל ונראה שיש לי פה חמש שגיאות כי לא מימשתי חמש פונקציות שקיימות באינטרפייס.
טוב, איך אנחנו עושים את זה? יש לנו פה את הקיצור הזה שאנחנו יכולים ללחוץ עליו ולכתוב Implement Interface iPlayer, או עדיף כמובן לא לגעת בעכבר,