דוגמה 1: ממשק ריק בגולנג
התחל עם הממשק הריק{} המכונה הממשק ב-Go. זה מציין סוג שיכול לאחסן כל סוג של ערך. להלן קוד המקור עבור הממשק הריק ב-Go:
חֲבִילָה רָאשִׁייְבוּא 'fmt'
סוּג מחשבון סימנים מִמְשָׁק {}
func רָאשִׁי () {
היה m MarksCalculator
fmt . Println ( M )
}
כאן, אנו מספקים את הקוד שבו לממשק 'MarksCalculator' אין חתימות שיטה מסויימות מכיוון שהוא ריק. כתוצאה מכך, זה לא מספק שום פונקציונליות. לאחר מכן, יש לנו את הפונקציה main() של הממשק הריק הזה שבו מוצהר משתנה 'm' מסוג MarksCalculator. מכיוון שהממשק ריק, 'm' יכול להחזיק כל ערך מכל סוג שהוא. במקרה זה, 'm' אינו מאתחל, ולכן יש לו ערך אפס לסוג שלו שהוא 'אפס' עבור ממשקים. כאשר 'm' מודפס באמצעות 'fmt.Println' הוא מוציא 'אפס' לקונסולה.
הפלט שאוחזר הוא 'אפס' כצפוי מקוד המקור הקודם:
דוגמה 2: הטמעת ממשק של Golang
חלק זה מדגים את היישום של ממשק גולנג. סוג חייב להציע את היישום עבור כל אחת מהשיטות שצוינו בממשק כדי ליישם אותה ב-Go. להלן קוד המקור ליישום הממשק:
חֲבִילָה רָאשִׁי
יְבוּא (
'fmt'
)
סוּג תנועות מִמְשָׁק {
חיפוש תנועות () [] רונה
}
סוּג MyStr חוּט
func ( st MyStr ) חיפוש תנועות () [] רונה {
היה תנועות [] רונה
ל _ , רונה := טווח רחוב {
אם רונה == 'א' || רונה == 'זה' || רונה == 'אני' || רונה == 'או' || רונה == 'ב' {
תנועות = לְצַרֵף ( תנועות , רונה )
}
}
לַחֲזוֹר תנועות
}
func רָאשִׁי () {
NewString := MyStr ( 'ממשקי GoLang' )
היה v1 תנועות
v1 = NewString
fmt . Printf ( 'תנועות הן %c' , v1 . חיפוש תנועות ())
}
כאן, הקוד מגדיר ממשק בשם 'Vowels' המציין שיטה יחידה SearchVwels() שמחזירה פרוסה של הרונה (סוג int32). ממשק מאפשר להקצות כל סוג שמיישם חתימת שיטה זו למשתנה מסוג הממשק. לאחר מכן, מוצהר סוג 'MyStr' חדש שהוא כינוי למחרוזת הסוג הבסיסית. המשמעות היא ש-'MyStr' יורש את כל שיטות המחרוזת אך הוא סוג מובחן.
לאחר מכן, אנו מיישמים את שיטת SearchVwels() עבור סוג 'MyStr'. שיטה זו סורקת את מחרוזת הקלט תו אחר תו ובודקת אם כל תו הוא תנועות ('a', 'e', 'i', 'o' או 'u'). אם תו הוא תנועות, הוא מצורף לפרוסת התנועה.
בתוך הפונקציה main() נוצר משתנה 'NewString' מסוג 'MyStr' עם הערך 'GoLang Interfaces'. לאחר מכן, משתנה 'v1' מסוג 'נקודים' מוכרז. מכיוון ש-'MyStr' מיישם את שיטת SearchVwels() המוגדרת בממשק 'Vwels', ניתן להקצות את ה-'NewString' ל-'v1'.
הפלט מציג את כל מערך התנועות שנמצאים במחרוזת שצוינה:
דוגמה 3: ממשק מחרוזת Golang
בנוסף, ל-Golang יש את ממשק 'Stringer' המוגדר מראש בחבילת 'fmt'. זה מאפשר לסוג מותאם אישית לשלוט בייצוג המחרוזת שלו כאשר הוא מעוצב עם הפועל '%v' בפונקציות ההדפסה של החבילה 'fmt'. להלן הקוד לדוגמה עבור ממשק ה-stringer של Go:
חֲבִילָה רָאשִׁייְבוּא (
'fmt'
)
סוּג סטוּדֶנט מבנה {
שֵׁם חוּט
תוֹאַר חוּט
}
func ( s סטודנט ) חוּט () חוּט {
לַחֲזוֹר fmt . ספרינטף ( '%s הוא (n) %s' , ס . שֵׁם , ס . תוֹאַר )
}
func רָאשִׁי () {
s1 := סטוּדֶנט { 'אלנה גילברט' , 'מדעי המחשב' }
s2 := סטוּדֶנט { 'קרוליין קנדיס' , 'BBA' }
fmt . Println ( s1 )
fmt . Println ( s2 )
}
כאן, הקוד מייבא תחילה את החבילה הדרושה שהיא 'fmt' להדפסה לקונסולה. לאחר מכן, אנו מגדירים סוג מבנה 'סטודנט' עם שני שדות: 'שם' ו'תואר'. מבנה זה מייצג מידע של תלמיד. יתר על כן, נוצרת שיטת String() עבור סוג 'סטודנט'. לשיטה זו יש מקלט מסוג 'סטודנט' ומחזירה מחרוזת. שיטת 'String()' היא שיטה מיוחדת ב-Go המשמשת להתאמה אישית של ייצוג המחרוזת של אובייקט כאשר הוא מודפס. במקרה זה, שיטת 'String()' מעצבת ומחזירה מחרוזת הכוללת את שם התלמיד והתואר.
לאחר מכן, יש לנו את הפונקציה main() שבה מוצהרים שני משתנים, s1 ו-s2 מסוג 'סטודנט', ומאוחלים עם מידע תלמיד. לבסוף, הקוד משתמש בפונקציה fmt.Println() כדי להדפיס את הערכים של s1 ו-s2. מכיוון שהמתודה String() מוגדרת לסוג 'Student', Go קורא לשיטה זו באופן אוטומטי בעת הדפסת האובייקט 'Student'. שיטת String() מעצבת את המידע של התלמיד באמצעות הפונקציה 'fmt.Sprintf()' ומחזירה את המחרוזת המעוצבת.
הפלט הבא מדפיס את האובייקט מסוג 'סטודנט' של ממשק המחרוזות:
דוגמה 4: ממשק מתג סוג Golang
ואז מגיע ממשק החלפת הסוג של Go. מתג סוג הוא מבנה בקרה המאפשר לנו לבדוק את הסוג הדינמי של ערך ממשק. עקוב אחר קוד המקור של ממשק החלפת סוג:
חֲבִילָה רָאשִׁייְבוּא 'fmt
func MyFunction(ממשק F1{}) {
מתג F1.(סוג) {
מקרה קודש:
fmt.Println(' סוּג : int , ערך : ', F1.(אתה))
מחרוזת מקרה:
fmt.Println(' \n הקלד : חוּט , ערך : ', F1.(מחרוזת))
case float64:
fmt.Println(' \n הקלד : לצוף64 , ערך : ', F1.(float64))
בְּרִירַת מֶחדָל:
fmt.Println(' \nהסוג אינו חוקי ')
}
}
func main() {
MyFunction(' מדריך ממשקי גולנג ')
MyFunction(89.7)
MyFunction (true)
}
כאן, הקוד שסופק מגדיר פונקציה 'MyFunction' שלוקחת פרמטר 'F1' מסוג 'ממשק{}'. זה מציין ש'F1' יכול לקבל ערך מכל סוג שהוא. בתוך הפונקציה, נעשה שימוש במשפט switch עם 'F1.(type)' כדי לבדוק את סוג הערך המועבר ל-'MyFunction'. התחביר '.(type)' משמש במתג סוג כדי לקבל את הסוג הדינמי הבסיסי של ערך ממשק. שימו לב שמקרי המתגים כאן מטפלים בשלושה סוגים ספציפיים: 'int', 'string' ו-'float64'. אם הסוג 'F1' תואם לאחד מהמקרים הללו. הוא מדפיס את הסוג והערך המתאימים באמצעות קביעות הסוג (F1.(int), F1.(מחרוזת), F1.(float64)). אם הסוג 'F1' אינו תואם לאף אחד מהמקרים שהוגדרו, מופעלת מקרה ברירת המחדל אשר מדפיס 'הסוג אינו חוקי'.
לאחר מכן, בתוך הפונקציה main(), 'MyFunction' נקרא שלוש פעמים עם ערכים שונים: מחרוזת, float64 ובוליאנית (שאינה מטופלת במשפט ה-switch).
הפלט מציג את ההדגמה של ממשק המתג עם הצהרות הסוג:
דוגמה 5: ממשקים מרובים של גולנג
יתר על כן, Go מציעה ממשקים מרובים המאפשרים לה לספק קבוצות שונות של התנהגויות בהתאם להקשר. תכונה זו נקראת 'ממשקים מרובים' או 'הרכב ממשק'. הקוד הבא מדגים את יישום ריבוי הממשקים:
חֲבִילָה רָאשִׁייְבוּא 'fmt'
סוּג ציפורים מִמְשָׁק {
לִנְשׁוֹם ()
לטוס, זבוב ()
}
סוּג עופות מִמְשָׁק {
הזנה ()
}
סוּג איפה מבנה {
גיל int
}
func ( ד איפה ) לִנְשׁוֹם () {
fmt . Println ( 'יונה נושמת' )
}
func ( ד איפה ) לטוס, זבוב () {
fmt . Println ( 'עוף יונה' )
}
func ( ד איפה ) הזנה () {
fmt . Println ( 'יונה מטפחת תינוקות' )
}
func רָאשִׁי () {
היה ב ציפורים
ד := איפה {}
ב = ד
ב . לִנְשׁוֹם ()
ב . לטוס, זבוב ()
היה עופות
א = ד
א . הזנה ()
}
כאן, אנו מגדירים שני ממשקים: 'ציפורים' ו'עופות'. ממשק 'ציפורים' מכריז על שתי שיטות: breathe() ו-fly(). בעוד שממשק 'aviaans' מכריז על שיטת feed() . לאחר מכן, מבנה ה'יונה' מיישם את כל השיטות של ממשק 'ציפורים' וגם של 'עופות'. הוא מספק את ההטמעות עבור breathe(), fly() ו-feed().
לאחר מכן, אנו מכריזים על המשתנה 'b' מסוג 'ציפורים' בתוך הפונקציה main() . מופע של 'יונה' נוצר ומוקצה ל-'b' באמצעות הקצאת b = d. מכיוון ש'יונה' מיישמת את כל השיטות של ממשק 'ציפורים', המשימה הזו תקפה.
לאחר מכן, השיטות breathe() ו-fly() נקראות על 'b' שהוא מסוג 'ציפורים'. באופן דומה, משתנה 'a' מסוג 'עופות' מוכרז ומוקצה למופע 'יונה' של 'd'. מכיוון ש-'dove' מיישמת את שיטת ה-feed() המוגדרת בממשק 'avians', גם ההקצאה הזו תקפה. שיטת feed() נקראת על 'a' שהוא מסוג 'עופות'. מכיוון ש-'a' מחזיק את מופע ה-'dove', שיטת ה-feed() שמיושמת על-ידי ה-'dove' מבוצעת.
הפלט מראה ששיטות הממשקים מבוצעות כהלכה:
סיכום
למדנו את היסודות של ממשקי Go וסיפקנו דוגמאות מעשיות כדי להמחיש את השימוש בהם. על ידי הגדרת ממשקים והטמעתם עם סוגים שונים, נוכל ליצור תוכניות גמישות וניתנות להרחבה.