פולימורפיזם - ההתחלה


שיעור פתיחה בנושא

הקודם – שאלון הורשה ובנאים · הבא – דף עזר להמרות ופולימורפיזם

פולימורפיזם (“ריבוי צורות”) הוא עיקרון מרכזי ב-OOP. המשמעות היא היכולת של פעולה אחת לקבל מימושים שונים במחלקות שונות. כך ניתן לכתוב קוד כללי יותר, המשתמש במחלקת בסיס, והמערכת מפעילה בזמן ריצה את המימוש המתאים של הפעולה לפי סוג האובייקט בפועל.

מומלץ תחילה לעבור על המצגת שכאן

משתנה מטיפוס אב שמפנה לעצם מטיפוס בן

בשורה Animal pet = new Dog(); הטיפוס המוצהר של המשתנה pet הוא Animal. הטיפוס של העצם שנוצר הוא Dog. ההשמה מותרת כי כל Dog הוא גם Animal. זוהי המרה משתמעת מבן לאב (upcast).

using System;

class Animal
{
    public virtual string Speak() => "Animal sound";
}

class Dog : Animal
{
    public override string Speak() => "Woof!";
    public void Bark() => Console.WriteLine("Bark!");
}

class Program
{
    static void Main()
    {
        Animal pet = new Dog();

        Console.WriteLine(pet.Speak()); // Woof!
        // pet.Bark();                  // CS1061

        Dog sameDog = (Dog)pet;
        sameDog.Bark();                 // Bark!

        if (pet is Dog dog)
        {
            dog.Bark();                 // Bark!
        }
    }
}
  • pet.Speak() מתקמפלת כי הפעולה זמינה דרך Animal. בזמן הריצה, מאחר ש-Speak היא virtual והעצם הוא Dog, רץ המימוש שהוגדר עם override ב-Dog.
  • pet.Bark() גורמת לשגיאת קומפילציה כי Bark מוגדרת רק ב-Dog. כדי לקרוא לה צריך ביטוי שהטיפוס שלו הוא Dog, למשל ((Dog)pet).Bark().
  • pet is Dog dog בודק אם העצם מתאים ל-Dog. כשהבדיקה מצליחה, dog הוא משתנה מטיפוס Dog שמפנה לאותו עצם.

pet, sameDog ו-dog מפנים לאותו כלב כאשר התנאי מתקיים. הטיפוס המוצהר של pet נשאר Animal. אפשר לקרוא ל-Bark דרך sameDog או דרך dog בתוך ה-if.

מה קורה כשהעצם הוא רק Animal?

אם נחליף את שורת ההשמה ב-Animal pet = new Animal();, הקריאה pet.Speak() תחזיר Animal sound. ההמרה (Dog)pet תתקמפל ותזרוק InvalidCastException בזמן הריצה. אם נריץ את ה-if בלי ההמרה המפורשת שלפניו, התנאי יהיה false וגוף התנאי לא יתבצע.

סוגי פולימורפיזם

  • העמסה (overload) היא בחירת חתימה מתאימה בזמן קומפילציה. עבור משתנים, הבחירה נשענת על הטיפוסים המוצהרים של המקבל ושל הארגומנטים.
  • דריסה (override) קובעת בזמן ריצה איזה מימוש של הפעולה הווירטואלית שנבחרה יופעל, לפי טיפוס העצם בפועל.

דוגמה: צורות גאומטריות

נבנה היררכיית מחלקות:

  • Shape - מחלקת בסיס עם פעולה ()Area.
  • Rectangle - יורשת מ-Shape ומחשבת שטח מלבן.
  • Square - יורשת מ-Rectangle (ריבוע הוא מלבן מיוחד).
  • Circle - יורשת מ-Shape ומחשבת שטח מעגל.

כל תא במערך Shape[] יכול להכיל הפניה למלבן, לריבוע או למעגל. בלולאה, המשתנה s הוא מטיפוס Shape, ולכן אפשר לקרוא ל-s.Area() בכל איטרציה. כל עצם מפעיל את מימוש חישוב השטח שמתאים לו דרך virtual ו-override.


תרשים UML

classDiagram class Shape { +Area() double +ToString() string } class Rectangle { -width : double -height : double +Area() double +ToString() string } class Square { +Area() double +ToString() string } class Circle { -radius : double +Area() double +ToString() string } Shape <|-- Rectangle Shape <|-- Circle Rectangle <|-- Square

חזרה על כללי כתיבת UML (Unified Modeling Language)

- private יסומנו בתחילית -

+ public יסומנו בתחילית +.

🠈 הורשה מסומנת בחץ 🠈 מהיורש למוריש. ראש החץ חלול, ולא מלא.

─♦ הכלה מסומנת ב ─♦ (לאדם יש יד. למכונית יש גלגלים).

─◇ אגרגציה מסומנת ב ─◇ (מכונית מכילה נוסעים, אבל יש להם קיום משל עצמם).

  • מומלץ ליצור תרשימים כאלו במרמייד. אפשר להעזר ב-AI.

קוד C

📄 לחצו להצגת הקוד
using System;

class Shape
{
    public virtual double Area() => 0.0;

    public override string ToString() => "Shape";
}

class Rectangle : Shape
{
    protected double width;
    protected double height;

    public Rectangle(double width, double height)
    {
        this.width = width;
        this.height = height;
    }

    public override double Area() => width * height;

    public override string ToString() => $"Rectangle({width}x{height})";
}

class Square : Rectangle
{
    public Square(double side) : base(side, side) { }

    public override string ToString() => $"Square({width})";
}

class Circle : Shape
{
    private double radius;

    public Circle(double radius)
    {
        this.radius = radius;
    }

    public override double Area() => Math.PI * radius * radius;

    public override string ToString() => $"Circle({radius})";
}

class ShapesDemo
{
    static void Main()
    {
        Shape[] shapes = new Shape[3];
        shapes[0] = new Rectangle(3, 4);
        shapes[1] = new Circle(5);
        shapes[2] = new Square(2);

        foreach (Shape s in shapes)
        {
            Console.WriteLine($"{s} area = {s.Area()}");
        }
    }
}

פלט אפשרי

Rectangle(3x4) area = 12
Circle(5) area = 78.53981633974483
Square(2) area = 4

יתרונות הפולימורפיזם

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

דף עזר להמרות ופולימורפיזם