פולימורפיזם באמצעות ממשקים

חלק מהיחידה תכנות מונחה עצמים במסלול ה-GO של Coddy. שיעור 41 מתוך 107.

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

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

type Speaker interface {
    Speak() string
}

type Dog struct{ Name string }
func (d Dog) Speak() string { return "Woof!" }

type Cat struct{ Name string }
func (c Cat) Speak() string { return "Meow!" }

func MakeSound(s Speaker) {
    fmt.Println(s.Speak())
}

עכשיו MakeSound פועלת עם כל טיפוס שיש לו מתודה Speak():

func main() {
    dog := Dog{Name: "Rex"}
    cat := Cat{Name: "Whiskers"}
    
    MakeSound(dog)  // הב הב!
    MakeSound(cat)  // מיאו!
}

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

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

אתגר

קל

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

תארגנו את הקוד שלכם בשני קבצים:

vehicles.go: הגדירו ממשק Describer שדורש מתודה Describe() string. לאחר מכן צרו שלושה סוגי כלי רכב, שכל אחד מהם מממש את הממשק בדרכו:
- Car עם שדות Brand ו-Model. המתודה Describe() שלו מחזירה Car: [Brand] [Model]
- Motorcycle עם השדות Brand ו-EngineCC (int). המתודה Describe() שלו מחזירה Motorcycle: [Brand] [EngineCC]cc
- Bicycle עם השדה Type (כמו "Mountain" או "Road"). המתודה Describe() שלו מחזירה Bicycle: [Type]
main.go: צרו פונקציה בשם PrintDescription שמקבלת כל ערך שמממש את Describer ומדפיסה את התוצאה של קריאה ל-Describe(). קראו את פרטי כלי הרכב מהקלט, צרו כלי רכב אחד מכל סוג, והעבירו כל אחד מהם אל PrintDescription כדי להדגים שאותה פונקציה עובדת עם שלושת הסוגים השונים.

הקלטים הבאים יסופקו:

שורה 1: יצרן המכונית
שורה 2: דגם המכונית
שורה 3: יצרן האופנוע
שורה 4: נפח המנוע של האופנוע בסמ"ק (מספר שלם)
שורה 5: סוג האופניים

לדוגמה, בהינתן Toyota, Camry, Honda, 600 ו-Mountain, הפלט שלכם צריך להיות:

Car: Toyota Camry
Motorcycle: Honda 600cc
Bicycle: Mountain

שימו לב ש-PrintDescription לא צריכה לדעת אם היא מקבלת Car, Motorcycle או Bicycle. היא פשוט קוראת ל-Describe(), וכל סוג מחזיר פלט ייחודי משלו. זהו פולימורפיזם: פונקציה אחת, התנהגויות מרובות.

נסו בעצמכם

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

// TODO: צרו פונקציה בשם PrintDescription שמקבלת כל Describer
// ומדפיסה את התוצאה של קריאה ל-Describe()

func main() {
	reader := bufio.NewReader(os.Stdin)

	// קראו את פרטי המכונית
	carBrand, _ := reader.ReadString('\n')
	carBrand = strings.TrimSpace(carBrand)
	carModel, _ := reader.ReadString('\n')
	carModel = strings.TrimSpace(carModel)

	// קראו את פרטי האופנוע
	motoBrand, _ := reader.ReadString('\n')
	motoBrand = strings.TrimSpace(motoBrand)
	motoEngineStr, _ := reader.ReadString('\n')
	motoEngineStr = strings.TrimSpace(motoEngineStr)
	motoEngine, _ := strconv.Atoi(motoEngineStr)

	// קראו את פרטי האופניים
	bicycleType, _ := reader.ReadString('\n')
	bicycleType = strings.TrimSpace(bicycleType)

	// TODO: צרו Car, Motorcycle ו-Bicycle באמצעות ערכי הקלט

	// TODO: קראו ל-PrintDescription עבור כל כלי רכב כדי להדגים פולימורפיזם
	fmt.Println("TODO: Print vehicle descriptions")
}