דילוג לתוכן המרכזי

סיכום נושא בחירה: תכנות מונחה עצמים

מדעי המחשב לבגרות · 8 נושאים

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

תכנות מונחה עצמים

בתכנות מונחה עצמים בונים את התוכנית ממחלקות ומעצמים שמתקשרים זה עם זה. בנושא הבחירה הזה לומדים לארגן מחלקות במשפחות: מחלקה כללית (כלי רכב) ומחלקות שיורשות ממנה (מכונית, משאית), כך שכל קוד נכתב פעם אחת בלבד.
במדויק: במיקוד תשפ"ז נכללים פרקים 1-5 של התכנית, כולל מערך של עצמים: מחלקות ועצמים, הפניות, פעולה בונה ופעולה בונה מעתיקה, תכונות ופעולות סטטיות, הרשאות גישה, ירושה, דריסה, העמסה, פולימורפיזם, המרה למעלה ולמטה ו-instanceof / is. לא נכללים: ממשקים (פרק 6) ושפות תכנות (פרק 7). בשאלון 899271 זה המסלול של שאלות 10-12, ולכל שאלה נוסח ב-Java ונוסח ב-C#.

הנושא ממשיך את המחלקות של 899371 (תכונות, פעולה בונה, get ו-set, מחלקה מורכבת). מה שחדש כאן: ירושה, ושאלות מעקב שבהן צריך להבחין בין הטיפוס של ההפניה לבין הטיפוס של העצם.

טיפוס ההפניה וטיפוס העצם

בשורה Animal a = new Bird("white", 4, false); יש שני טיפוסים: המשתנה a הוא מטיפוס Animal, והעצם שנוצר הוא Bird. כמעט כל שאלה בנושא בודקת אם אתם יודעים איזה מהם קובע מה.
במדויק: טיפוס ההפניה (הטיפוס המוצהר) נקבע בהצהרה, והמהדר בודק לפיו אילו פעולות מותר לזמן ואיזו חתימה נבחרת. טיפוס העצם (הטיפוס בפועל) נקבע ב-new, ובזמן ריצה הוא קובע איזו גרסה של פעולה דרוסה מתבצעת. מותר שהפניה מטיפוס של מחלקת בסיס תפנה לעצם של מחלקה יורשת, ולא להפך.

1. מחלקות, עצמים והפניות: פעולה בונה ופעולה בונה מעתיקה

עצם, הפניה ופעולה בונה

משתנה מטיפוס מחלקה לא "מכיל" את העצם: הוא מכיל חץ אל העצם. לכן שני משתנים יכולים להפנות לאותו עצם, ושינוי דרך אחד מהם נראה גם דרך השני.
במדויק: new יוצר עצם חדש ומפעיל עליו פעולה בונה - פעולה בשם המחלקה, בלי טיפוס מוחזר, שמאתחלת את התכונות. למחלקה יכולות להיות כמה פעולות בונות עם רשימות פרמטרים שונות (העמסה). פעולה בונה מעתיקה מקבלת עצם מאותה מחלקה ובונה עצם חדש עם אותם ערכים. השמה a4 = a1 מעתיקה רק את ההפניה, ולא יוצרת עצם.

בשאלות מציירים עצמים בתרשים עצמים: מלבן לכל עצם, ובראשו שם המחלקה; לכל משתנה חץ אל העצם שלו; תכונה שהיא עצם (הכלה) היא חץ למלבן נוסף, או null. זה ההמשך של המחלקה המורכבת מ-899371.

העתקת הפניה מול יצירת עצם

מה כתובמה קורהכמה עצמים
a4 = a1;a4 מפנה לאותו עצם כמו a1אף עצם חדש
a4 = new AA(a1);פעולה בונה מעתיקה: עצם חדש עם אותם ערכיםעצם חדש אחד
this.f = f; (בפעולה בונה)התכונה מפנה לעצם שהתקבל כפרמטראף עצם חדש
this.f = new AA(f);התכונה מפנה להעתק חדש של העצםעצם חדש אחד
a4 == a1האם שתי ההפניות מפנות לאותו עצם-
new AA[6]מערך של 6 הפניות, כולן nullאף עצם AA

תבנית: פעולות בונות ופעולה בונה מעתיקה

public class Contract
{
    private String name;
    private int days;
    private int kilo;

    public Contract(String name, int days, int kilo)
    {
        this.name = name;
        this.days = days;
        this.kilo = kilo;
    }

    public Contract(Contract other)   // פעולה בונה מעתיקה
    {
        this.name = other.name;
        this.days = other.days;
        this.kilo = other.kilo;
    }

    public String toString()
    {
        return name + " " + days + " " + kilo;
    }
}

בהרצה: c2 = new Contract(c1) הוא עצם חדש עם Dana 3 100, ולכן c2 == c1 הוא false. לעומתו c3 = c1 מפנה לאותו עצם, ו-c3 == c1 הוא true.

דרך הפתרון

כתיבת פעולות בונות לפי תרשים עצמים

1.ממיינים את הקריאות לפי הפרמטרים: new AA(), new AA(8) ו-new AA(a1) הן שלוש פעולות בונות שונות (העמסה).
2.קוראים את הערכים מהתרשים: מה ערך כל תכונה בכל עצם, ומה קבוע (למשל: new AA() תמיד x = 2).
3.תכונה שהיא עצם: אם החץ בתרשים מצביע לעצם שכבר קיים (f = a4) - this.f = f. אם הוא מצביע למלבן חדש - this.f = new AA(f).
4.תכונה פרטית של מחלקת הבסיס: המחלקה היורשת קובעת אותה רק דרך super(...) / : base(...).
5.בסוף: טבלה - לכל עצם, איזו פעולה בונה יצרה אותו.
שים לב

בתוך המחלקה AA מותר לקרוא other.x גם כש-x היא private: ההרשאה היא לפי מחלקה, לא לפי עצם. לכן הפעולה הבונה המעתיקה לא צריכה get. במחלקה BB (יורשת) זה כבר אסור, וגם "לשתי המחלקות אין פעולות get ו-set" - ולכן BB מעתיקה עצם AA רק בעזרת new AA(f).

שים לב

אם הפעולה הבונה של BB לא קוראת במפורש ל-super(...) / : base(...), מופעלת AA() - ואז x מקבל את הערך של AA() (בשאלה: 2), לא את מה שבתרשים. כש-new BB() צריך לתת x = 1 כותבים super(1).

דוגמה - פעולות בונות לפי תרשים עצמים

לפניכם כותרות המחלקות AA ו-BB והתכונות שלהן. לשתי המחלקות אין פעולות get ו-set.

public class AA
{
    private int x;
    // הפעולות הבונות - להשלים
}

public class BB extends AA
{
    private AA f;
    // הפעולות הבונות - להשלים
}

לפניכם המחלקה Test:

public class Test
{
    public static void main(String[] args)
    {
        AA a1 = new AA();
        AA a2 = new AA(8);
        AA a3 = new AA(3);
        AA a4 = new AA(a1);
        AA a5 = new AA(a2);
        BB b1 = new BB();
        BB b2 = new BB(6, a4);
        BB b3 = new BB(5, a2);
        BB b4 = new BB(a4);
        BB b5 = new BB(a2);
    }
}

בתרשים העצמים שנוצרו (מלבן לכל עצם):

משתנהמחלקת העצםxf
a1AA2-
a2AA8-
a3AA3-
a4AA2-
a5AA8-
b1BB1null
b2BB6a4
b3BB5a2
b4BB0חץ לעצם AA נוסף עם x = 2
b5BB0חץ לעצם AA נוסף עם x = 8

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

פתרון
1.AA: קריאות בלי פרמטר, עם int ועם AA - שלוש פעולות בונות. new AA() נותן x = 2. a4 הוא עצם נפרד עם x = 2 כמו a1 - פעולה בונה מעתיקה.
2.BB: קריאות בלי פרמטר, עם (int, AA) ועם AA - שוב שלוש. x פרטית ב-AA, ולכן קובעים אותה רק דרך super / base. ב-b1 x = 1, ולכן super(1) ולא super().
3.f: ב-b2 וב-b3 f מפנה ל-a4 ול-a2 עצמם - מעתיקים את ההפניה. ב-b4 וב-b5 f מפנה לעצם חדש - new AA(f), ו-x = 0.
public class AA
{
    private int x;

    public AA()
    {
        this.x = 2;
    }

    public AA(int x)
    {
        this.x = x;
    }

    public AA(AA other)   // פעולה בונה מעתיקה
    {
        this.x = other.x;
    }
}

public class BB extends AA
{
    private AA f;

    public BB()
    {
        super(1);
        this.f = null;
    }

    public BB(int x, AA f)
    {
        super(x);
        this.f = f;            // אותו עצם
    }

    public BB(AA f)
    {
        super(0);
        this.f = new AA(f);    // עצם חדש, העתק
    }
}
עצםהקריאההפעולה הבונהמה מתקבל
a1new AA()AA()x = 2
a2, a3new AA(8), new AA(3)AA(int x)x = 8, x = 3
a4, a5new AA(a1), new AA(a2)AA(AA other)עצמים חדשים, x = 2, x = 8
b1new BB()BB()x = 1, f = null
b2, b3new BB(6, a4), new BB(5, a2)BB(int x, AA f)x = 6 ו-f הוא a4; x = 5 ו-f הוא a2
b4, b5new BB(a4), new BB(a2)BB(AA f)x = 0, f עצם חדש עם x = 2 / x = 8
4.בדיקה: בהרצה, ערכי x של a1 עד a5 הם 2, 8, 3, 2, 8, ו-a4 == a1 הוא false. b1: x = 1, f = null; b2: x = 6, f הוא a4 עצמו; b3: x = 5, f הוא a2 עצמו; b4 ו-b5: x = 0, ו-f עצם חדש עם x = 2 ו-x = 8.
תשובה

AA: AA() מציבה x = 2; AA(int x); AA(AA other) מציבה x = other.x.
BB: BB() - super(1), f = null; BB(int x, AA f) - super(x), this.f = f; BB(AA f) - super(0), this.f = new AA(f).

2. תכונת מחלקה (static) והרשאות גישה

תכונת מחלקה

לפעמים צריך ערך אחד ששייך למחלקה כולה ולא לכל עצם בנפרד, למשל מונה של כמה עצמים נוצרו. תכונה כזאת מסמנים static.
במדויק: תכונת מחלקה (static) קיימת בעותק אחד לכל העצמים של המחלקה ושל המחלקות היורשות ממנה. כל שינוי שלה נראה מכל עצם. מחוץ למחלקה פונים אליה דרך שם המחלקה, למשל AAA.c. הרשאות גישה: private - רק בתוך המחלקה; protected - גם במחלקות היורשות; public - מכל מקום.

בשאלות static מופיעה כמעט תמיד כמונה שגדל בפעולה בונה, יחד עם שרשור פעולות בונות (שיעור הירושה): צריך לדעת איזו פעולה בונה רצה בכל new, ולכן גם כמה פעמים המונה גדל.

הרשאות גישה

הרשאהמי ניגש ישירות
privateרק המחלקה עצמה. מחלקה יורשת ניגשת רק דרך get / set או דרך super(...) / : base(...)
protectedהמחלקה והמחלקות שיורשות ממנה
publicכל מחלקה

תכונות מגדירים בדרך כלל private (הסתרת מידע). protected משתמשים כשהשאלה צריכה שהמחלקה היורשת תיגש לתכונה ישירות, למשל this.num = num בפעולה הבונה של Son.

תבנית: מונה עצמים

public class One
{
    public static int count = 0;   // תכונת מחלקה: אחת לכל העצמים
    private int number;            // תכונה של כל עצם

    public One()
    {
        count++;
        number = count;
    }

    public String toString()
    {
        return count + ", " + number;
    }
}

בהרצה: אחרי new One() ראשון מודפס 1, 1. אחרי שלושה עצמים, כל אחד מהם מודפס עם 3: 3, 1, 3, 2, 3, 3 - כי count משותפת, ו-number נשמרה ברגע היצירה.

דרך הפתרון

מעקב אחר תכונת מחלקה

1.לכל new: כותבים את שרשרת הפעולות הבונות שרצות (גם קריאות מובלעות ל-super() / base()).
2.מסמנים אילו מהן משנות את התכונה הסטטית, ומעדכנים עמודה אחת שלה לאורך כל הקוד.
3.תכונות של העצם (כמו number) נקבעות ברגע היצירה ונשארות.
4.בהדפסה: התכונה הסטטית מודפסת עם הערך ברגע ההדפסה, לא ברגע היצירה.
שים לב

כשמדפיסים את כל העצמים בלולאה אחרי שכולם נוצרו, התכונה הסטטית זהה בכל השורות. ב-One, Two, Three של קיץ 2025 בכל שש השורות מודפס 4, ולא 1, 1 Fast בשורה הראשונה.

שים לב

תכונה סטטית private במחלקת הבסיס (st של Father) לא נגישה למחלקה היורשת. אם Son צריכה להגדיל אותה, היא קוראת לפעולה הבונה של Father שעושה זאת (super() / : base()).

דוגמה א - השלמת יצירת עצמים לפי פלט עם מונה

נתונות המחלקות One, Two, Three:

public class One
{
    public static int count = 0;
    private int number;

    public One()
    {
        count++;
        number = count;
    }

    public One(int num)
    {
        number = num;
    }

    public String toString()
    {
        return count + ", " + number;
    }
}

public class Two extends One
{
    private String strTwo;

    public Two()
    {
        strTwo = "Fast";
    }

    public Two(String s)
    {
        super(15);
        strTwo = s;
    }

    public String toString()
    {
        return super.toString() + " " + strTwo;
    }
}

public class Three extends Two
{
    private String strThree;

    public Three(String s)
    {
        strThree = s;
    }

    public String toString()
    {
        return super.toString() + " " + strThree;
    }
}

בפעולה main / Main של המחלקה Test נוצר מערך One[] arr = new One[6]. בשורות (1)-(6) מציבים עצם בכל אחד מהתאים arr[0] עד arr[5], ואחר כך מדפיסים בלולאה את כל התאים לפי הסדר.
השלימו את השורות (1)-(6) כך שהפלט יהיה:

4, 1 Fast
4, 2 Fast Car
4, 3 Fast Horse
4, 15 Small
4, 15 Tall
4, 4
פתרון
1.count משותפת, וגדלה רק ב-One(). כל השורות מודפסות אחרי היצירה ומראות 4, ולכן One() רצה בדיוק 4 פעמים.
2.שרשור: Two() קוראת במובלע ל-One() (count גדל) ו-strTwo = "Fast". Two(String s) קוראת ל-One(15) - count לא גדל, number = 15. Three(String s) קוראת במובלע ל-Two() ומשם ל-One().
3.number ב-One() מקבלת את count באותו רגע - 1, 2, 3, 4 לפי סדר היצירה.
שורהעצםcount אחרי היצירהnumberמודפס
(1)new Two()114, 1 Fast
(2)new Three("Car")224, 2 Fast Car
(3)new Three("Horse")334, 3 Fast Horse
(4)new Two("Small")3154, 15 Small
(5)new Two("Tall")3154, 15 Tall
(6)new One()444, 4
public class Test
{
    public static void main(String[] args)
    {
        One[] arr = new One[6];
        arr[0] = new Two();            // (1)
        arr[1] = new Three("Car");     // (2)
        arr[2] = new Three("Horse");   // (3)
        arr[3] = new Two("Small");     // (4)
        arr[4] = new Two("Tall");      // (5)
        arr[5] = new One();            // (6)
        for (int i = 0; i < arr.length; i++)
        {
            System.out.println(arr[i]);
        }
    }
}
4.בדיקה: ההרצה מדפיסה בדיוק את ששת השורות הנדרשות.
תשובה

(1) new Two() (2) new Three("Car") (3) new Three("Horse") (4) new Two("Small") (5) new Two("Tall") (6) new One()

דוגמה ב - השלמת מחלקת בסיס: תכונות, הרשאות וכותרות

נתונה המחלקה BBB, היורשת ממחלקה AAA:

public class BBB extends AAA
{
    private char ch;

    public BBB(int num, char ch)
    {
        super(num);
        this.ch = ch;
    }

    public BBB(char ch) { this.ch = ch; }
    public int gg(int val) { return super.gg(val) + num; }
    public int mm() { return AAA.c + 2; }
    public boolean nn() { return this.mm(10); }
}

כתבו במחלקה AAA את תכונות המחלקה (כולל הרשאות הגישה) ואת הכותרות של הפעולות הנדרשות כדי שהמחלקה BBB תהיה תקינה. אין צורך לממש את הפעולות. אין לשנות את BBB.

פתרון

עוברים על BBB שורה אחר שורה ושואלים מה היא צריכה מ-AAA:

שורה ב-BBBמה נדרש ב-AAA
super(num) / : base(num)פעולה בונה AAA(int num)
BBB(char ch) בלי קריאה מפורשתמופעלת AAA() - פעולה בונה בלי פרמטרים
... + numתכונה int num שנגישה ליורשת - protected
super.gg(val)public int gg(int val). ב-C# BBB כותבת override, ולכן ב-AAA public virtual int GG(int val)
AAA.c + 2תכונת מחלקה מטיפוס שלם - protected static int c
this.mm(10) מחזירה booleanב-BBB יש רק mm() בלי פרמטרים, ולכן ב-AAA העמסה: public boolean mm(int x)
public class AAA
{
    protected int num;          // BBB משתמשת ב-num
    protected static int c;     // AAA.c - תכונת מחלקה

    public AAA() { }                              // בשביל BBB(char ch)
    public AAA(int num) { }                       // בשביל super(num)
    public int gg(int val) { return 0; }          // BBB דורסת
    public boolean mm(int x) { return false; }    // העמסה: this.mm(10)
}

(גופי הפעולות ריקים רק כדי שהקוד יעבור הידור; בבחינה מספיקות הכותרות.)
בדיקה: AAA יחד עם BBB ללא שינוי עוברות הידור ורצות.

תשובה

protected int num; protected static int c; · public AAA() · public AAA(int num) · public int gg(int val) (ב-C#: public virtual int GG(int val)) · public boolean mm(int x) (ב-C#: public bool MM(int x))

3. מערך של עצמים והפעולה main

מערך של עצמים

מערך של עצמים הוא מערך של הפניות. כשיוצרים אותו אין בו עדיין אף עצם - כל תא הוא null, ואת העצמים יוצרים אחד אחד.
במדויק: new Animal[5] יוצר מערך של 5 הפניות null. כל תא מקבל עצם ב-new נפרד, ותא במערך מטיפוס מחלקת בסיס יכול להפנות גם לעצם של מחלקה יורשת. כשהמערך הוא תכונה של מחלקה, שומרים לידו count - כמה תאים תפוסים, ברצף מתחילת המערך. הפעולה main (public static void main(String[] args) / public static void Main(string[] args)) היא נקודת ההתחלה של התוכנית: בשאלות היא נמצאת במחלקה Tester או Test, יוצרת את העצמים ומדפיסה.

בשאלון 899371 של תשפ"ז מערך של עצמים לא נכלל, ובנושא הבחירה הוא נכלל. הסריקה זהה לסריקת מערך רגיל, אבל ניגשים לנתונים דרך פעולות: arr[i].getInstrum().

מערך עם count

מהJavaC#
יצירת המערךarrM = new Musician[size];arrM = new Musician[size];
האם יש מקוםcount < arrM.lengthcount < arrM.Length
הוספה בסוףarrM[count] = m; count++;אותו דבר
סריקהfor (int i = 0; i < count; i++)אותו דבר
הדפסת עצםSystem.out.println(arr[i]) - מפעיל את toStringConsole.WriteLine(arr[i]) - מפעיל את ToString

תבנית: מחלקה עם מערך של עצמים

public class Orchestra
{
    private Musician[] arrM;
    private int count;   // כמה נגנים שמורים במערך

    public Orchestra(int size)
    {
        this.arrM = new Musician[size];   // size הפניות, כולן null
        this.count = 0;
    }

    public boolean add(Musician m)       // הוספה בסוף הרצף
    {
        if (this.count == this.arrM.length)
            return false;
        this.arrM[this.count] = m;
        this.count++;
        return true;
    }

    public void printAll()               // סריקה עד count, לא עד length
    {
        for (int i = 0; i < this.count; i++)
            System.out.println(this.arrM[i]);
    }
}

בהרצה עם מערך בגודל 2: שתי ההוספות הראשונות מחזירות true, השלישית false, ו-printAll מדפיסה רק את שני הנגנים.

הפעולה main: יצירת מערך ועצמים

public class Tester
{
    public static void main(String[] args)
    {
        Animal[] animals = new Animal[3];          // 3 הפניות null
        animals[0] = new Bird("white", 4, false);  // עצם לכל תא
        animals[1] = new Fish("blue", 3, "sweet water");
        animals[2] = new Parrot("brown", 12, true, true);
        for (int i = 0; i < animals.length; i++)
            System.out.println(animals[i]);         // toString של כל עצם
    }
}

כל תא מקבל עצם משלו, וכל עצם מודפס לפי ה-toString של המחלקה שלו.

דרך הפתרון

הכנסה למקום מסוים במערך עם count

1.יש מקום? אם count == arr.length מחזירים false.
2.מוצאים את המקום pos: סורקים מ-0 עד count ועוצרים במקום שבו העצם החדש צריך להיות.
3.מזיזים ימינה את התאים מ-pos עד count - 1, מהסוף להתחלה: arr[i] = arr[i - 1] עבור i מ-count עד pos + 1.
4.מציבים את העצם ב-pos, מגדילים את count ומחזירים true.
שים לב

לולאה עד arrM.length במקום עד count מגיעה לתאים ריקים, ו-arrM[i].getInstrum() על null נכשל בזמן ריצה. בשאלה כתוב: "הנגנים מופיעים ברצף מתחילת המערך ללא null ביניהם, אך ייתכן שהמערך אינו מלא עד הסוף".

שים לב

הזזה משמאל לימין (for i = pos ... עם arr[i + 1] = arr[i]) מעתיקה את אותו עצם לכל התאים. מזיזים מהסוף להתחלה.

דוגמה - הכנסת נגן למערך מסודר לפי סוג הכלי

במחלקה Orchestra (תזמורת) שתי תכונות: arrM - מערך של נגנים (Musician), ו-count - כמות הנגנים השמורים במערך. הנגנים מופיעים ברצף מתחילת המערך, ללא null ביניהם. לנגן יש פעולה getInstrum / GetInstrum שמחזירה את הכלי שלו (Instrum). המחלקות Bow (קשת), Wind (נשיפה) ו-Perc (הקשה) יורשות מ-Instrum.
מערך arrM "מסודר" הוא מערך שבו מופיעים קודם נגני כלי הקשת, אחר כך נגני כלי הנשיפה, ואחר כך נגני כלי ההקשה.
כתבו במחלקה Orchestra פעולה ששמה insert / Insert, המקבלת נגן musician שאינו מופיע במערך. הניחו שהמערך "מסודר" ושיש בתזמורת לפחות נגן אחד בכל סוג של כלי. אם אין מקום לנגן נוסף, הפעולה תחזיר false. אחרת היא תכניס את הנגן כך שהמערך ימשיך להיות "מסודר" (ברצף בתחילת המערך) ותחזיר true. מותר לשנות את סדר הנגנים.

פתרון
1.אין מקום: count == arrM.length - false.
2.pos לפי סוג הכלי (בודקים בעזרת instanceof / is):
•הקשה - בסוף הרצף: pos = count.
•קשת - הנגן הראשון שאינו נגן קשת.
•נשיפה - נגן ההקשה הראשון.
3.הזזה מהסוף ל-pos, הצבה, count++, true.
public boolean insert(Musician musician)
{
    if (this.count == this.arrM.length)       // אין מקום
        return false;
    Instrum ins = musician.getInstrum();
    int pos = this.count;                      // הקשה: בסוף הרצף
    if (ins instanceof Bow)                    // קשת: אחרי נגן הקשת האחרון
    {
        pos = 0;
        while (pos < this.count && this.arrM[pos].getInstrum() instanceof Bow)
            pos++;
    }
    else if (ins instanceof Wind)              // נשיפה: לפני נגן ההקשה הראשון
    {
        pos = 0;
        while (pos < this.count && !(this.arrM[pos].getInstrum() instanceof Perc))
            pos++;
    }
    for (int i = this.count; i > pos; i--)     // הזזה ימינה, מהסוף להתחלה
        this.arrM[i] = this.arrM[i - 1];
    this.arrM[pos] = musician;
    this.count++;
    return true;
}
4.בדיקה: מערך בגודל 9 עם b1 b2 w1 p1 p2 p3 (count = 6):
פעולהמוחזרהמערך אחרי הפעולה
הכנסת w2 (נשיפה)trueb1 b2 w1 w2 p1 p2 p3 (count = 7)
הכנסת b3 (קשת)trueb1 b2 b3 w1 w2 p1 p2 p3 (count = 8)
הכנסת p4 (הקשה)trueb1 b2 b3 w1 w2 p1 p2 p3 p4 (count = 9)
הכנסת b4 (קשת)falseהמערך מלא ולא השתנה
תשובה

אם המערך מלא - false. אחרת pos = count לנגן הקשה, אחרי נגן הקשת האחרון לנגן קשת, לפני נגן ההקשה הראשון לנגן נשיפה; מזיזים ימינה מ-pos, מציבים, count++ ומחזירים true.

4. ירושה: מחלקה יורשת, super / base ושרשור פעולות בונות

ירושה

ירושה היא הדרך לומר "תוכי הוא סוג של ציפור, וציפור היא סוג של בעל חיים". המחלקה היורשת מקבלת את כל התכונות והפעולות של מחלקת הבסיס, ומוסיפה רק את מה שמיוחד לה.
במדויק: ב-Java כותבים class Bird extends Animal, וב-C# class Bird : Animal. היורשת מקבלת את כל התכונות (גם private - הן קיימות בעצם, אבל ניגשים אליהן רק דרך פעולות או דרך protected) ואת כל הפעולות. פעולות בונות לא עוברות בירושה: כל פעולה בונה של היורשת מפעילה קודם פעולה בונה של מחלקת הבסיס - במפורש (super(...) / : base(...)), או במובלע את הפעולה הבונה בלי פרמטרים.

הירושה מייצגת את היחס "סוג של" (is a). היחס "יש לו" הוא הכלה - ראו שיעור תכנון המחלקות.

ירושה ב-Java וב-C#

מהJavaC#
כותרתpublic class Bird extends Animalpublic class Bird : Animal
קריאה לפעולה הבונה של הבסיסsuper(color, weight); - השורה הראשונה בגוף: base(color, weight) - אחרי הכותרת, לפני {
קריאה לפעולה של הבסיסsuper.toString()base.ToString()
בלי קריאה מפורשתמופעלת Animal()מופעלת Animal()
תכונה שהיורשת ניגשת אליהprotectedprotected

תבנית: שרשור פעולות בונות

public class Animal
{
    private String color;
    private int weight;

    public Animal(String color, int weight)
    {
        this.color = color;
        this.weight = weight;
    }
}

public class Bird extends Animal
{
    private boolean isFlying;

    public Bird(String color, int weight, boolean isFlying)
    {
        super(color, weight);   // שורה ראשונה: הבונה של Animal
        this.isFlying = isFlying;
    }
}

public class Parrot extends Bird
{
    private boolean isTalking;

    public Parrot(String color, int weight, boolean isFlying, boolean isTalking)
    {
        super(color, weight, isFlying);   // הבונה של Bird
        this.isTalking = isTalking;
    }
}

בהרצה: new Parrot("brown", 12, true, true) מאתחל את ארבע התכונות - color ו-weight ב-Animal, isFlying ב-Bird ו-isTalking ב-Parrot.

דרך הפתרון

שרשור פעולות בונות: מה רץ ובאיזה סדר

1.מוצאים את הפעולה הבונה לפי הפרמטרים שב-new.
2.עולים למעלה: אם בה super(...) / : base(...) - זו הפעולה הבונה של הבסיס שרצה. אם אין - רצה הפעולה הבונה בלי פרמטרים של הבסיס. ממשיכים כך עד המחלקה העליונה.
3.מבצעים מלמעלה למטה: קודם גוף הפעולה הבונה של מחלקת הבסיס העליונה, ואחר כך הגופים של היורשות, לפי הסדר.
4.כותבים פעולה בונה: את תכונות הבסיס מעבירים ב-super(...) / : base(...), ובגוף מאתחלים רק את התכונות החדשות.
שים לב

this.color = color; בפעולה הבונה של Bird הוא שגיאת הידור: color היא private ב-Animal. וגם פעולה בונה בלי super(...) לא תעבור הידור כשלמחלקת הבסיס אין פעולה בונה בלי פרמטרים.

שים לב

אם Son(int num) נכתבת כ-this(num, 'Z'), היא מפעילה את Son(int, char), שמפעילה את Father() - ו-st גדל פעם נוספת. בודקים כל פעולה בונה מול הפלט הנדרש.

דוגמה - מימוש פעולות בונות לפי פלט נתון

לפניכם המחלקה Father בלי מימוש הפעולות הבונות, והמחלקה Son בלי מימוש הפעולות הבונות ובלי הפעולה toString:

public class Father
{
    private static int st = 0;
    protected int num;

    public Father() { }           // להשלים
    public Father(int num) { }    // להשלים

    public String toString() { return "st=" + st + ", num=" + num; }
}

public class Son extends Father
{
    private char ch;

    public Son(int num, char ch) { }   // להשלים
    public Son(int num) { }            // להשלים
    // toString - להשלים
}

לפניכם קטע קוד:

Father x1 = new Father();
System.out.println(x1);      // 1
Father x2 = new Father(3);
System.out.println(x2);      // 2
Father x3 = new Son(5, 'A');
System.out.println(x3);      // 3
Father x4 = new Son(7);
System.out.println(x4);      // 4

והפלט שהתקבל:

st=1, num=9          //1
st=1, num=3          //2
st=2, num=5, ch=A    //3
st=2, num=7, ch=Z    //4

ממשו את הפעולות הבונות ב-Father וב-Son, ואת toString / ToString ב-Son, כך שיתקבל הפלט. אין להוסיף פעולות נוספות.

פתרון
1.//1 new Father() - st = 1, num = 9: הבונה בלי פרמטרים מגדילה את st ומציבה 9.
2.//2 new Father(3) - st לא השתנה: הבונה עם פרמטר רק מציבה num.
3.//3 new Son(5, 'A') - st = 2. רק Father() מגדילה את st, ו-st היא private - ולכן super() / : base(). num היא protected, ולכן Son מציבה this.num = num.
4.//4 new Son(7) - st לא השתנה, ch = Z: super(num) / : base(num) ו-ch = 'Z'.
5.toString של Son: super.toString() ועוד ", ch=" + ch, בלי לשכפל קוד.
public class Father
{
    private static int st = 0;
    protected int num;

    public Father()
    {
        st++;
        this.num = 9;
    }

    public Father(int num)
    {
        this.num = num;
    }

    public String toString() { return "st=" + st + ", num=" + num; }
}

public class Son extends Father
{
    private char ch;

    public Son(int num, char ch)
    {
        super();          // הבונה היחידה שמגדילה את st
        this.num = num;   // num היא protected
        this.ch = ch;
    }

    public Son(int num)
    {
        super(num);       // לא מגדילה את st
        this.ch = 'Z';
    }

    public String toString()
    {
        return super.toString() + ", ch=" + this.ch;
    }
}
6.בדיקה: ההרצה מדפיסה st=1, num=9, st=1, num=3, st=2, num=5, ch=A, st=2, num=7, ch=Z.
תשובה

Father(): st++, num = 9 · Father(int num): this.num = num · Son(int num, char ch): super(), num = num, ch = ch · Son(int num): super(num), ch = 'Z' · toString: super.toString() + ", ch=" + ch

5. דריסה, העמסה ופולימורפיזם

דריסה ופולימורפיזם

כל כלי רכב משלם לפי חישוב אחר, אבל רוצים לכתוב arr[i].payment() בלי לבדוק מה הוא. בשביל זה כל מחלקה יורשת כותבת גרסה משלה לאותה פעולה.
במדויק: דריסה - פעולה במחלקה יורשת עם אותה כותרת בדיוק (שם, פרמטרים, טיפוס מוחזר) כמו פעולה של מחלקת הבסיס. העמסה - כמה פעולות עם אותו שם ורשימות פרמטרים שונות, באותה מחלקה או לאורך ההיררכייה. פולימורפיזם - זימון פעולה דרך הפניה מטיפוס הבסיס מפעיל את הגרסה של העצם בפועל. ב-Java כל פעולה ניתנת לדריסה. ב-C# הפעולה בבסיס מסומנת virtual והדורסת override (וגם public override string ToString()).

הדריסה הנפוצה ביותר בבחינות היא של toString / ToString: println(arr[i]) מדפיס לפי המחלקה של העצם. לפעולה הדורסת מותר להשתמש בגרסה של הבסיס בעזרת super.f() / base.F().

דריסה מול העמסה

דריסההעמסה
הכותרתזהה לזו של הבסיסאותו שם, פרמטרים שונים
איפהבמחלקה יורשתבאותה מחלקה או ביורשת
מתי נבחרתבזמן ריצה, לפי טיפוס העצםבזמן הידור, לפי טיפוסי ההפניה והארגומנטים
ב-C#virtual בבסיס, override ביורשתבלי מילה מיוחדת
דוגמהpayment() ב-Vehicle וב-Truckfoo(Object) ו-foo(B, int) ב-B

תבנית: דריסה שמשתמשת בגרסת הבסיס

public class Animal
{
    private String color;
    private int weight;

    public Animal(String color, int weight)
    {
        this.color = color;
        this.weight = weight;
    }

    public String toString()
    {
        return "My color is " + this.color + "! And I weigh " + weight + " kilos!";
    }
}

public class Bird extends Animal
{
    private boolean isFlying;

    public Bird(String color, int weight, boolean isFlying)
    {
        super(color, weight);
        this.isFlying = isFlying;
    }

    public String toString()   // דריסה: אותה כותרת בדיוק
    {
        return "I'm a bird! " + super.toString();
    }
}

בהרצה: עצם Animal מודפס My color is blue! And I weigh 3 kilos!, ועצם Bird (גם דרך הפניה מטיפוס Animal) מודפס I'm a bird! My color is white! And I weigh 4 kilos!.

דרך הפתרון

פעולה שמתנהגת אחרת לכל סוג

1.כותבים את הפעולה במחלקת הבסיס עם ההתנהגות הכללית (ב-C#: virtual).
2.דורסים רק איפה שצריך: מחלקה שמתנהגת כמו הבסיס לא כותבת את הפעולה - היא יורשת אותה.
3.בדריסה משתמשים בבסיס: super.payment() + 500 / base.Payment() + 500, במקום להעתיק את החישוב (ובמקום לגשת לתכונות פרטיות).
4.לא בודקים סוג: בלי instanceof / is. הבחירה בין הגרסאות נעשית לבד בזמן ריצה.
שים לב

ב-C# יש דריסה רק כשהפעולה מסומנת virtual בבסיס ו-override ביורשת. override על פעולה שאינה virtual היא שגיאת הידור, ובלי override אין דריסה: זימון דרך הפניה מטיפוס Vehicle יפעיל את הגרסה של Vehicle. וגם: ב-C# הרשאת הגישה של הפעולה הדורסת חייבת להיות זהה לזו של הבסיס (protected virtual בבסיס ו-public override ביורשת - שגיאת הידור).

שים לב

פעולה ביורשת עם פרמטרים שונים אינה דורסת - היא העמסה. ב-A, B, C, D של קיץ 2025 ל-D יש רק foo(B, int), ולכן bd.foo(b) עם ארגומנט אחד מפעילה את foo(Object) של B, גם כשהעצם הוא D.

דוגמה - תשלום לפי סוג כלי רכב בדריסה

במחלקה Vehicle (כלי רכב) התכונות id (מחרוזת) ו-contract (מטיפוס Contract). למחלקה Contract (חוזה) התכונות name, days (מספר ימי השכרה) ו-kilo (מספר הקילומטרים), עם פעולות get / Get. המחלקות Car, Truck ו-Motorcycle יורשות מ-Vehicle, ולכל אחת פעולה בונה שמעבירה (name, days, kilo, id) לפעולה הבונה של Vehicle.
התעריף הבסיסי הוא 60 שקלים ליום השכרה ו-2 שקלים לכל קילומטר. מכונית - לפי התעריף הבסיסי. משאית - התעריף הבסיסי ועוד 500 שקלים. אופנוע - מחצית מהתעריף הבסיסי.
הפעולה payment / Payment מחזירה מספר ממשי: הסכום לתשלום, בהתאם לעצם שזימן אותה.
(1) כתבו את payment במחלקה Vehicle.
(2) הוסיפו את payment רק במחלקות שיש בהן צורך. אין להשתמש ב-instanceof (ב-C#: is ו-as), ואין לשנות את התכונות.

פתרון
1.Vehicle: הימים והקילומטרים שמורים בחוזה, והתכונות שלו פרטיות - ניגשים דרך get. ב-C# הפעולה virtual.
public double payment()
{
    return 60 * this.contract.getDays() + 2 * this.contract.getKilo();
}
2.Car משלמת לפי התעריף הבסיסי - לא כותבים בה payment; היא יורשת.
3.Truck ו-Motorcycle דורסות ומשתמשות בגרסת הבסיס:
public class Truck extends Vehicle
{
    private int max;

    public Truck(String name, int days, int kilo, String id, int max)
    {
        super(name, days, kilo, id);
        this.max = max;
    }

    public double payment()
    {
        return super.payment() + 500;
    }
}

public class Motorcycle extends Vehicle
{
    private boolean offRoad;

    public Motorcycle(String name, int days, int kilo, String id, boolean offRoad)
    {
        super(name, days, kilo, id);
        this.offRoad = offRoad;
    }

    public double payment()
    {
        return super.payment() / 2;
    }
}
4.בדיקה: 3 ימים ו-100 ק"מ: 60·3 + 2·100 = 380. מערך עם Vehicle, Car, Truck ו-Motorcycle מחזיר 380.0, 380.0, 880.0, 190.0.
תשובה

(1) return 60 * contract.getDays() + 2 * contract.getKilo(); (ב-C#: public virtual double Payment()).
(2) ב-Car אין צורך. Truck: return super.payment() + 500; Motorcycle: return super.payment() / 2; (ב-C#: override ו-base.Payment()).

6. המרת טיפוסים ו-instanceof / is

המרה למעלה והמרה למטה

מערך של Animal יכול להכיל ציפורים ודגים, אבל דרך הפניה מטיפוס Animal רואים רק את מה שיש ב-Animal. כדי להפעיל פעולה של ציפור צריך קודם לבדוק שהעצם באמת ציפור, ורק אז "להמיר" אליו.
במדויק: המרה למעלה (מיורשת לבסיס) היא אוטומטית: Animal a = new Bird(...). המרה למטה כותבים במפורש: (Bird) a. המהדר בודק רק שההמרה אפשרית לפי ההיררכייה. בזמן ריצה, אם העצם אינו מהטיפוס (או מטיפוס שיורש ממנו), נזרקת חריגה: ClassCastException ב-Java, InvalidCastException ב-C#. לפני המרה בודקים: a instanceof Bird ב-Java, a is Bird ב-C#. על null הבדיקה מחזירה false.

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

מה עובר הידור ומה עובר ריצה

שורה (B יורשת מ-A)הידורריצה
A x = new B();תקיןתקין
B y = new A();שגיאה-
B y = x; (x מטיפוס A)שגיאה: צריך המרה-
B y = (B) x;תקיןתקין רק אם העצם הוא B או יורש מ-B, אחרת חריגה
x.f(), כש-f קיימת רק ב-Bשגיאה: אין f ב-A-
((B) x).f()תקיןכמו ההמרה
x instanceof B / x is Bתקיןtrue אם העצם הוא B או יורש מ-B

תבנית: בדיקת סוג, המרה וזימון

public int withSticks()
{
    int sum = 0;
    for (int i = 0; i < this.count; i++)
    {
        Instrum ins = this.arrM[i].getInstrum();
        if (ins instanceof Perc && ((Perc) ins).getHasSticks())   // בדיקה, ואז המרה
            sum++;
    }
    return sum;
}

בהרצה על תזמורת עם שני נגני קשת, נגן נשיפה ושלושה נגני הקשה (שניים מהם עם מקלות) הפעולה מחזירה 2.

דרך הפתרון

האם השורה תקינה

1.הידור - השמה: X r = new Y() תקינה רק אם Y היא X או יורשת ממנה (ישירות או בעקיפין).
2.הידור - זימון: הפעולה צריכה להיות קיימת בטיפוס ההפניה (או במחלקות שהוא יורש מהן). לא מסתכלים על העצם.
3.ריצה - המרה: (Y) r מצליחה רק אם העצם הוא Y או יורש מ-Y.
4.תיקון: עוטפים ב-if (r instanceof Y) / if (r is Y) וממירים בתוך התנאי.
שים לב

המרה לא משנה את העצם, רק את טיפוס ההפניה. ((AA) items[3]).goo() על עצם BB מפעילה את goo של BB, כי goo נדרסת.

שים לב

כשבשאלה כתוב "אין להשתמש בפעולה instanceof" (ב-C#: is ו-as), הפתרון הוא דריסה: כל מחלקה כותבת את הגרסה שלה, והבחירה נעשית בזמן ריצה.

דוגמה א - תיקון זימון של פעולה שקיימת רק ביורשת

המחלקות Bird, Fish ו-Snake יורשות מ-Animal, ו-Parrot יורשת מ-Bird. הפעולה zoo / Zoo (מדפיסה Hello) מוגדרת רק ב-Bird. בפעולה main נוצר המערך:
animals = {Bird, Fish, Parrot, Snake, Snake} (מטיפוס Animal).
במחלקה Tester נוספה הפעולה:

public static void hello(Animal[] arr)
{
    for (int i = 0; i < arr.length; i++)
    {
        arr[i].zoo();
    }
}

אם הפעולה תקינה, כתבו את הפלט שלה עבור animals. אם לא - תקנו אותה (כך שהקריאה ל-zoo בתוך הלולאה תהיה תקינה) וכתבו את הפלט. אין לשנות את המחלקות, והפעולה צריכה לרוץ ללא שגיאות עבור כל מערך מטיפוס Animal.

פתרון
1.הידור: הטיפוס של arr[i] הוא Animal, וב-Animal אין zoo. לכן זו שגיאת הידור (בהרצה: cannot find symbol ... method zoo() ... location: class Animal; ב-C#: 'Animal' does not contain a definition for 'Zoo'), גם כשהעצם הוא Bird.
2.תיקון: בודקים שהעצם הוא ציפור, ורק אז ממירים ל-Bird. Parrot יורשת מ-Bird, ולכן גם תוכי עובר את הבדיקה. בלי הבדיקה, המרה של Fish ל-Bird הייתה זורקת חריגה בזמן ריצה.
public static void hello(Animal[] arr)
{
    for (int i = 0; i < arr.length; i++)
    {
        if (arr[i] instanceof Bird)
        {
            ((Bird) arr[i]).zoo();
        }
    }
}
3.בדיקה: עבור animals - Bird ו-Parrot מדפיסים, Fish ו-Snake לא. הפלט:
Hello
Hello

במערך עם Fish, תא null ו-Parrot מודפס Hello אחד, בלי שגיאה.

תשובה

הפעולה לא תקינה (ב-Animal אין zoo). תיקון: if (arr[i] instanceof Bird) ((Bird) arr[i]).zoo(); (ב-C#: is Bird ו-Zoo()). הפלט: Hello, Hello.

דוגמה ב - אילו תרשימי ירושה מתאימים לקוד תקין

נתונות המחלקות A, B, C, D והפעולה main שרצה באופן תקין:

public class Tester
{
    public static void main(String[] args)
    {
        C c1 = new B();
        A a1 = new C();
        A a2 = new B();
        C c2 = new D();
    }
}

ששה תרשימי הייררכייה (לכל תרשים: איזו מחלקה יורשת מאיזו):

תרשיםיחסי הירושה
1B יורשת מ-C; D יורשת מ-B; A יורשת מ-B
2C יורשת מ-A; B יורשת מ-C; D יורשת מ-C
3B יורשת מ-D; C יורשת מ-D; A יורשת מ-C
4C יורשת מ-A; B יורשת מ-C; D יורשת מ-B
5A יורשת מ-B; C יורשת מ-A; D יורשת מ-C
6C יורשת מ-A; D יורשת מ-C; B יורשת מ-D

(1) לכל תרשים: ייתכן או לא ייתכן? אם לא - נמקו.
(2) בסוף main נוספו השורות הבאות, שרצות באופן תקין. האם התשובה ל-(1) משתנה? נמקו.

A a3 = new B();
D d1 = (D) a3;
פתרון
1.דרישות מ-main: C c1 = new B() - B יורשת מ-C. A a1 = new C() - C יורשת מ-A. C c2 = new D() - D יורשת מ-C. (ישירות או בעקיפין.)
תרשיםייתכן?נימוק
1לאC היא מחלקת הבסיס של כולן ולא יורשת מ-A: A a1 = new C() שגיאת הידור
2כןB ו-D יורשות מ-C, ו-C מ-A
3לאB ו-C "אחיות" תחת D: C c1 = new B() שגיאת הידור
4כןB מ-C, C מ-A, ו-D מ-C דרך B
5לאB היא השורש ולא יורשת מ-C: C c1 = new B() שגיאת הידור
6כןB מ-C דרך D, C מ-A, D מ-C
2.השורות הנוספות: a3 מפנה לעצם B. (D) a3 עוברת הידור (D יורשת מ-A), אבל בזמן ריצה מצליחה רק אם B יורשת מ-D. בתרשים 2 B ו-D אחיות, ובתרשים 4 D יורשת מ-B - בשניהם חריגה בזמן ריצה. רק בתרשים 6 B יורשת מ-D.
public class A { }
public class C extends A { }
public class D extends C { }
public class B extends D { }
3.בדיקה: בנינו את A-D לפי כל תרשים. בתרשימים 1, 3, 5 - שגיאת הידור. בתרשימים 2 ו-4 main רצה, ועם השורות הנוספות נזרקה ClassCastException. בתרשים 6 הכול רץ.
תשובה

(1) 1 - לא ייתכן; 2 - ייתכן; 3 - לא ייתכן; 4 - ייתכן; 5 - לא ייתכן; 6 - ייתכן.
(2) כן: ההמרה (D) a3 של עצם B מצליחה רק אם B יורשת מ-D, ולכן נשאר רק תרשים 6 (ב-2 וב-4 שגיאת ריצה).

7. תכנון מחלקות ותרשים היררכייה

תרשים הייררכייה

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

בסיכום הזה התרשים כתוב בטבלה: לכל מחלקה - ממי היא יורשת ואת מי היא מכילה.

ירושה או הכלה

שאלהאם כןבקודבתרשים
X הוא סוג של Y? (מכונית היא כלי רכב)ירושהclass X extends Y / class X : Yחץ עם משולש ריק מ-X אל Y
ל-X יש Y? (לכלי רכב יש חוזה)הכלהתכונה private Y y; ב-Xמעוין מלא בצד של X
ל-X יש הרבה Y? (לתזמורת יש נגנים)הכלהתכונה private Y[] arr; ב-Xמעוין מלא בצד של X

תבנית: כותרות ותכונות

public class Contract
{
    private String name;
    private int days;
    private int kilo;
}

public class Vehicle
{
    private String id;
    private Contract contract;   // הכלה: לכלי רכב יש חוזה
}

public class Car extends Vehicle   // ירושה: מכונית היא סוג של כלי רכב
{
    private int seats;             // רק התכונה החדשה
}

public class Truck extends Vehicle
{
    private int max;
}

התכונות id ו-contract כתובות רק ב-Vehicle, ו-Car ו-Truck מקבלות אותן בירושה. הקוד עובר הידור, ועצם Car נכנס להפניה מטיפוס Vehicle.

דרך הפתרון

תכנון היררכייה מתיאור של מחלקות

1.רשימת תכונות: לכל מחלקה, התכונות והפעולות שבתיאור.
2.מוצאים חלק משותף: מחלקה שכל התכונות שלה מופיעות גם באחרות היא מחלקת הבסיס שלהן (Instrum עם name ו-material).
3."סוג של": לכל זוג שואלים "האם X הוא סוג של Y". אם ל-X יש את כל מה שיש ל-Y ועוד - ירושה. גם בין יורשות (תוכי הוא ציפור).
4."יש לו": תכונה שהיא עצם של מחלקה אחרת - הכלה.
5.כותבים את הכותרות, ובכל יורשת רק את התכונות החדשות. פעולה משותפת עולה לבסיס.
6.מציירים את התרשים עם כל המחלקות.
שים לב

נגן אינו "סוג של" כלי נגינה - יש לו כלי נגינה. לכן בין Musician ל-Instrum יש הכלה, לא ירושה. אותו דבר בין Vehicle ל-Contract.

שים לב

לא מגדירים שוב ביורשת תכונה שכבר יש בבסיס (id ו-contract ב-Car, name ו-material ב-Bow). בתיאור המחלקות בשאלה הן מופיעות בכל מחלקה, אבל בקוד הן נכתבות רק בבסיס.

דוגמה א - ארגון מחדש של מחלקות עם תכונות כפולות

במערכת של גן חיות נתונות המחלקות:

public class Animal
{
    private String color;
    private int weight;

    public Animal(String color, int weight)
    {
        this.color = color;
        this.weight = weight;
    }

    public String toString()
    {
        return "My color is " + this.color + "! And I weigh " + weight + " kilos!";
    }
}

public class Bird
{
    private String color;
    private int weight;
    private boolean isFlying;

    public void zoo()
    {
        System.out.println("Hello");
    }
}

public class Parrot
{
    private String color;
    private int weight;
    private boolean isFlying;
    private boolean isTalking;

    public void zoo()
    {
        System.out.println("Hello");
    }
}

public class Fish
{
    private String color;
    private int weight;
    private String waterType;     // דג ים / דג מים מתוקים
}

public class Snake
{
    private String color;
    private int weight;
    private int length;
    private boolean isVenomous;   // האם הנחש ארסי?
}

הניחו שיש פעולות get ו-set לתכונות.
א. כתבו מחדש את הכותרות, התכונות והפעולות של Bird, Parrot, Fish ו-Snake לפי עקרונות תכנות מונחה עצמים (אין לשנות את Animal), וצירו תרשים הייררכייה בין כל המחלקות.
ב. נתונה המחלקה Tester:

public class Tester
{
    public static void main(String[] args)
    {
        Animal[] animals = new Animal[5];
        animals[0] = new Bird("white", 4, false);
        animals[1] = new Fish("blue", 3, "sweet water");
        animals[2] = new Parrot("brown", 12, true, true);
        animals[3] = new Snake("gray", 2, 6, true);
        animals[4] = new Snake("black", 3, 4, false);
    }
}

הוסיפו פעולות בונות ל-Bird, Parrot, Fish ו-Snake כך ש-main תרוץ ללא שגיאות. אין לשנות את הפעולה הבונה של Animal.

פתרון
1.משותף: color ו-weight בכל המחלקות, והן כבר ב-Animal - כולן יורשות ממנה, ומוחקים מהן את color ו-weight.
2.תוכי הוא ציפור: Bird ו-Parrot חולקות גם isFlying ו-zoo. Parrot יורשת מ-Bird ומוסיפה רק isTalking.
3.Fish ו-Snake יורשות ישירות מ-Animal עם התכונות המיוחדות להן.
מחלקהיורשת מ-תכונות חדשות
Animal-color, weight
BirdAnimalisFlying (ו-zoo)
ParrotBirdisTalking
FishAnimalwaterType
SnakeAnimallength, isVenomous
4.פעולות בונות: סדר הפרמטרים לפי הקריאות ב-main. color ו-weight פרטיות ב-Animal, ול-Animal אין פעולה בונה בלי פרמטרים - לכן בכל אחת super(color, weight) / : base(color, weight). Parrot קוראת לבונה של Bird.
public class Bird extends Animal
{
    private boolean isFlying;

    public Bird(String color, int weight, boolean isFlying)
    {
        super(color, weight);
        this.isFlying = isFlying;
    }

    public void zoo()
    {
        System.out.println("Hello");
    }
}

public class Parrot extends Bird   // תוכי הוא ציפור
{
    private boolean isTalking;

    public Parrot(String color, int weight, boolean isFlying, boolean isTalking)
    {
        super(color, weight, isFlying);
        this.isTalking = isTalking;
    }
}

public class Fish extends Animal
{
    private String waterType;

    public Fish(String color, int weight, String waterType)
    {
        super(color, weight);
        this.waterType = waterType;
    }
}

public class Snake extends Animal
{
    private int length;
    private boolean isVenomous;

    public Snake(String color, int weight, int length, boolean isVenomous)
    {
        super(color, weight);
        this.length = length;
        this.isVenomous = isVenomous;
    }
}
5.בדיקה: Animal עם המחלקות האלה ו-Tester עוברות הידור, ו-main רצה ללא שגיאות.
תשובה

א. Bird יורשת מ-Animal (isFlying, zoo); Parrot יורשת מ-Bird (isTalking); Fish יורשת מ-Animal (waterType); Snake יורשת מ-Animal (length, isVenomous). color ו-weight רק ב-Animal.
ב. Bird: super(color, weight); Parrot: super(color, weight, isFlying); Fish ו-Snake: super(color, weight), ובכל אחת אתחול התכונות החדשות.

דוגמה ב - היררכייה עם ירושה והכלה מתיאור מילולי

באקדמיה למוזיקה המחלקות:

•Instrum (כלי נגינה): name, material (מחרוזות).
•Bow (כלי קשת): name, material, bowLength (שלם).
•Wind (כלי נשיפה): name, material, numberOfValves (שלם).
•Perc (כלי הקשה): name, material, hasSticks (בוליאני).
•Musician (נגן): name (מחרוזת), instrum (מטיפוס Instrum). כל נגן מנגן על כלי אחד.
•Orchestra (תזמורת): arrM - מערך של נגנים (Musician), count (שלם).

(1) סרטטו תרשים הייררכייה בין כל המחלקות.
(2) כתבו את כותרות המחלקות ואת התכונות שלהן. הניחו שקיימות פעולות get ו-set ופעולות בונות.

פתרון
1."סוג של": כלי קשת, נשיפה והקשה הם כלי נגינה, ולכולם name ו-material - Bow, Wind, Perc יורשות מ-Instrum.
2."יש לו": לנגן יש כלי - Musician מכילה Instrum. לתזמורת יש נגנים - Orchestra מכילה (מערך של) Musician.
מחלקהיורשת מ-מכילה
Instrum--
Bow, Wind, PercInstrum-
Musician-Instrum
Orchestra-מערך של Musician
public class Instrum
{
    private String name;
    private String material;
}

public class Bow extends Instrum
{
    private int bowLength;
}

public class Wind extends Instrum
{
    private int numberOfValves;
}

public class Perc extends Instrum
{
    private boolean hasSticks;
}

public class Musician
{
    private String name;
    private Instrum instrum;   // הכלה
}

public class Orchestra
{
    private Musician[] arrM;   // הכלה: מערך של נגנים
    private int count;
}
3.בדיקה: הכותרות עוברות הידור, ועצם Perc נכנס להפניה מטיפוס Instrum.
תשובה

(1) Bow, Wind, Perc יורשות מ-Instrum; Musician מכילה Instrum; Orchestra מכילה (מערך של) Musician.
(2) Instrum(name, material); Bow extends Instrum (bowLength); Wind extends Instrum (numberOfValves); Perc extends Instrum (hasSticks); Musician(name, instrum מטיפוס Instrum); Orchestra(arrM מטיפוס Musician[], count).

8. מעקב והדפסה בהיררכיית מחלקות

מעקב בהיררכיית מחלקות

שאלת המעקב בנושא הזה נראית כמו רשימה של println קצרות, אבל כל שורה היא חידה: איזו מבין כמה פעולות באותו שם תרוץ? התשובה מגיעה בשני שלבים קבועים.
במדויק: בזמן הידור בוחרים את החתימה (העמסה): מבין הפעולות שמוכרות לטיפוס ההפניה, זו שמתאימה ביותר לטיפוסי ההפניה של הארגומנטים. בזמן ריצה בודקים אם החתימה שנבחרה נדרסה במחלקה של העצם בפועל (או במחלקה בדרך אליו) - ואם כן, מתבצעת הגרסה הדורסת. גם זימון בתוך פעולה (goo() שהוא this.goo()) נבחר לפי העצם. super.f() / base.F() מפעילה תמיד את הגרסה של מחלקת הבסיס.

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

שני השלבים של כל זימון

שלבלפי מהמה נקבע
הידורטיפוס ההפניה שעליה מזמנים, וטיפוסי ההפניות של הארגומנטיםאיזו חתימה - למשל func(B) ולא func(A)
ריצהטיפוס העצם בפועלאיזו גרסה של החתימה - של הבסיס, או הדורסת
super.f() / base.F()המחלקה שבה כתובה הקריאהתמיד הגרסה של מחלקת הבסיס
המרה (B) x-משנה רק את טיפוס ההפניה, לא את העצם
דרך הפתרון

מעקב והדפסה בהיררכיה

1.טבלת עצמים: לכל משתנה - טיפוס ההפניה, טיפוס העצם (מה שאחרי new) וערכי התכונות. את התכונות מחשבים לפי שרשרת הפעולות הבונות, כולל קריאות מובלעות.
2.לכל שורת הדפסה: רושמים את טיפוס ההפניה ואת טיפוסי הארגומנטים, ומוצאים את החתימה (הידור).
3.בודקים דריסה: אם לחתימה יש גרסה במחלקת העצם - היא שרצה.
4.מחשבים עם ערכי התכונות של העצמים. אם הפעולה משנה תכונה - מעדכנים את טבלת העצמים (וזוכרים ששני משתנים יכולים להפנות לאותו עצם).
5.רושמים את הפלט עם מספר השורה, כולל הדפסות שבתוך הפעולות.
שים לב

טיפוס ההפניה של הארגומנט קובע את ההעמסה, לא טיפוס העצם. ב-A, B, C של קיץ 2026, ac.func(c): ל-A אין func(C), ולכן נבחרת func(B) - ובזמן ריצה רצה הגרסה הדורסת של C. ו-((B) ab).func(ab): ab מוצהר A, ולכן נבחרת func(A).

שים לב

פעולה בונה בלי super(...) מפעילה את הבונה בלי פרמטרים של הבסיס - והיא עצמה יכולה לקרוא לבונה אחרת. new C(0) מפעילה את B(), ו-B() מפעילה את A(2): num מתחיל ב-2, לא ב-1.

שים לב

ב-Java כל פעולה נדרסת בלי מילת מפתח. בנוסח C# של השאלונים הפעולות שנדרסות מסומנות virtual בבסיס ו-override ביורשת. בבחירת ההעמסה C# שונה מ-Java: מבין הפעולות המתאימות לארגומנטים, המהדר של C# בוחר קודם מאלה שהוגדרו (לא כ-override) במחלקה של טיפוס ההפניה, ועולה למחלקת הבסיס רק אם אין בה פעולה מתאימה - גם כשבבסיס יש פעולה מתאימה יותר. בשאלות המעקב של 2024-2026 זה לא משנה את התוצאה: ב-A, B, C של קיץ 2026, בשורה 10 נבחרת Func(C) של C, ובשורות 8-9 Func(C) לא מתאימה לארגומנט מטיפוס A, ולכן נבחרת Func(A) של B - כמו ב-Java. בפלט, ב-C# ערך בוליאני מודפס True / False.

דוגמה א - העמסה ודריסה בעשר שורות הדפסה

לפניכם המחלקות A, B, C:

public class A
{
    public int num;

    public A()
    {
        this.num = 1;
    }

    public A(int num)
    {
        this.num = num;
    }

    public int func(int val)
    {
        return val * 2;
    }

    public int func(B other)
    {
        return this.num - other.num;
    }
}

public class B extends A
{
    public B()
    {
        super(2);
    }

    public B(int val)
    {
        super(val);
        this.num = this.num + func(val);
    }

    public int func(A other)
    {
        return this.num + (other.num * 10);
    }

    public int func(B other)
    {
        return this.num + other.num;
    }
}

public class C extends B
{
    public C(int val)
    {
        this.num = this.num - val;
    }

    public int func(B other)
    {
        return this.num * other.num;
    }

    public int func(C c)
    {
        return this.num * 4;
    }
}

א. לפניכם קטע קוד שרץ ללא שגיאות. הציגו את העצמים שנוצרו (סוג העצם, סוג ההפניה וערך התכונה num).

A a = new A();
A ab = new B();
A ac = new C(0);
B b = new B(1);
B bc = new C(1);
C c = new C(1);

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

System.out.println(a.func(b));              // 1
System.out.println(a.func(c));              // 2
System.out.println(ab.func((B) ab));        // 3
System.out.println(((B) ab).func(ab));      // 4
System.out.println(ab.func(10));            // 5
System.out.println(a.func(a.func(2)));      // 6
System.out.println(ac.func(c));             // 7
System.out.println(c.func(ac));             // 8
System.out.println(c.func(a));              // 9
System.out.println(((C) bc).func((C) bc));  // 10
פתרון
1.הפעולות הבונות: A() - num = 1. B() - A(2). B(int val) - A(val) ואז num + func(val); הארגומנט int, ולכן func(int) של A: val * 2. C(int val) - במובלע B() (num = 2), ואז num - val.
הפניהסוג ההפניהסוג העצםnum
aAA1
abAB2
acAC2
bBB1 + 1·2 = 3
bcBC2 − 1 = 1
cCC1
2.הפלט: ל-A יש func(int), func(B); ל-B נוספת func(A) ודריסה של func(B); ל-C דריסה של func(B) ו-func(C) חדשה.
שורההפניה וטיפוס הארגומנטחתימה (הידור)מתבצעת (ריצה)חישובפלט
1a:A, Bfunc(B)של A1 − 3-2
2a:A, Cfunc(B) (C הוא B)של A1 − 10
3ab:A, Bfunc(B)של B (דריסה)2 + 24
4(B)ab:B, Afunc(A)של B2 + 2·1022
5ab:A, intfunc(int)של A10·220
6a:A, intfunc(int) פעמייםשל A2·2 = 4, 4·28
7ac:A, Cfunc(B) (ל-A אין func(C))של C (דריסה)2·12
8c:C, Afunc(A)של B (בירושה)1 + 2·1021
9c:C, Afunc(A)של B1 + 1·1011
10(C)bc:C, Cfunc(C)של C1·44
3.בדיקה: ההרצה נתנה את טבלת העצמים ואת הפלט -2, 0, 4, 22, 20, 8, 2, 21, 11, 4.
תשובה

א. a: A/A, num = 1 · ab: הפניה A, עצם B, num = 2 · ac: הפניה A, עצם C, num = 2 · b: B/B, num = 3 · bc: הפניה B, עצם C, num = 1 · c: C/C, num = 1.
ב. 1: -2 · 2: 0 · 3: 4 · 4: 22 · 5: 20 · 6: 8 · 7: 2 · 8: 21 · 9: 11 · 10: 4.

דוגמה ב - פעולת בסיס שקוראת לפעולה דרוסה

נתונות המחלקות AA ו-BB:

public class AA
{
    private int x;

    public AA() { this.x = 4; }
    public AA(int x) { this.x = x; }
    public int getX() { return this.x; }
    public void foo() { this.x = 3; }
    public void goo() { this.x = this.x + 3; }
    public void bar() { goo(); }
    public String toString() { return "x = " + this.x; }
}

public class BB extends AA
{
    private int y;

    public BB()
    {
        super();
        this.y = 2;
    }

    public BB(int a)
    {
        super(a);
        this.y = getX() * 2;
    }

    public BB(int a, int b)
    {
        super(a);
        this.y = b;
    }

    public int getY() { return this.y; }
    public void foo() { this.y = 5; }
    public void goo() { this.y = getX() - 1; }

    public void bar(int a)
    {
        this.y = a + getX() + this.y;
    }

    public String toString()
    {
        return super.toString() + "  y = " + this.y;
    }
}

בתחילת הקוד נוצרו העצמים:

AA[] items = new AA[6];
items[0] = new AA();
items[1] = new BB();
items[2] = new AA(2);
items[3] = new BB(2);
items[4] = new BB(1, 22);
items[5] = items[4];

(כלומר: items[0] - AA עם x = 4; items[1] - BB עם x = 4, y = 2; items[2] - AA עם x = 2; items[3] - BB עם x = 2, y = 4; items[4] ו-items[5] - אותו עצם BB עם x = 1, y = 22.)
לפניכם המשך הקוד. כתבו מה הוא מדפיס.

items[0].foo();
items[1].goo();
((AA) items[3]).goo();
items[4].bar();
BB temp = new BB(1);
temp.bar();
System.out.println("Temp: " + temp);
temp.bar(9);
items[2] = temp;
for (int i = 0; i < items.length; i++)
    System.out.println(items[i]);
פתרון
1.מה נדרס: foo ו-goo נדרסות ב-BB. ל-BB אין bar() בלי פרמטרים, רק bar(int) (העמסה) - ולכן bar() על עצם BB מפעילה את bar של AA, והיא קוראת ל-goo(), שנבחרת לפי העצם: goo של BB.
פקודההעצםמה רץשינוי
items[0].foo()AAfoo של AAx = 3
items[1].goo()BBgoo של BBy = 4 − 1 = 3
((AA) items[3]).goo()BBgoo של BB (ההמרה לא משנה את העצם)y = 2 − 1 = 1
items[4].bar()BBbar של AA, ומשם goo של BBy = 1 − 1 = 0 (גם items[5])
new BB(1)BBBB(int a)temp: x = 1, y = 2
temp.bar()BBbar של AA, ומשם goo של BBy = 0
הדפסהtoString של BBTemp: x = 1 y = 0
temp.bar(9)BBbar(int) של BBy = 9 + 1 + 0 = 10
items[2] = tempitems[2] מפנה ל-temp
2.בדיקה: ההרצה הדפיסה את השורות שבתשובה. x של עצמי BB לא משתנה אף פעם: foo ו-goo של AA לא רצות עליהם.
תשובה
Temp: x = 1  y = 0
x = 3
x = 4  y = 3
x = 1  y = 10
x = 2  y = 1
x = 1  y = 0
x = 1  y = 0

כל האתר במבט אחד

קיצורי דרך לכל הכלים, הבגרויות והקורסים

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