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

סיכום מחלקות ועצמים

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

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

מחלקה, עצם ומצב העצם

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

בשאלוני 2023-2026 הסעיף האחרון של שאלת המחלקה עוסק כמעט תמיד במערך של עצמים. מערך של עצמים לא במיקוד תשפ"ז של 899371, ולכן אין עליו כאן: הוא נלמד בנושא הבחירה תכנות מונחה עצמים.

1. מחלקה: תכונות, פעולה בונה, get ו-set

תכונות ופעולה בונה

כשיוצרים עצם חדש, צריך שיהיו לו מיד ערכים הגיוניים. הסעה בלי יום או חבילה בלי מחיר לא שוות כלום. בשביל זה יש פעולה בונה.
במדויק: תכונה היא משתנה של העצם, שמוגדר בראש המחלקה, תמיד private. פעולה בונה היא פעולה בשם המחלקה, בלי טיפוס מוחזר, שבונה עצם חדש ומאתחלת אותו למצב תקין: היא מציבה ערך בכל תכונה, מהפרמטרים או ערך שהשאלה קובעת. get מחזירה ערך של תכונה, ו-set משנה אותו. בשאלה כתוב בדרך כלל "הניחו שקיימות פעולות get/Get ו-set/Set לתכונות המחלקה", ולפעמים רק "פעולות get/Get". את הפעולות האלה לא כותבים.

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

התבנית: תכונות, פעולה בונה, get ו-set

המחלקה TourPackage מקיץ 2024: התכונות והפעולה הבונה כמו בשאלה. התכונה extra לא מתקבלת כפרמטר, ולכן הפעולה הבונה מציבה בה 0. בשאלה נאמר רק שקיימות פעולות get, והפעולה setPrice / SetPrice נוספה כאן רק כדי להראות איך נראית פעולת set:

public class TourPackage
{
    private int id;        // מספר זיהוי של לקוח
    private int price;     // מחיר החבילה
    private int maxTime;   // דקות שיחה בחבילה
    private int maxData;   // נפח גלישה בחבילה
    private int extra;     // תשלום על חריגה

    public TourPackage(int id, int price, int maxTime, int maxData)   // פעולה בונה
    {
        this.id = id;
        this.price = price;
        this.maxTime = maxTime;
        this.maxData = maxData;
        this.extra = 0;    // לא מתקבלת כפרמטר
    }

    public int getId() { return this.id; }           // get
    public int getExtra() { return this.extra; }     // get
    public void setPrice(int price) { this.price = price; }   // set
}

שלושה סוגי פעולות במחלקה

סוגמה היא עושהבכותרתדוגמה מהבגרות
פעולה בונהבונה עצם חדש ומאתחלת את כל התכונותשם המחלקה, בלי טיפוס מוחזרTransport(int num)
שאילתהמחזירה ערך ולא משנה את מצב העצםטיפוס מוחזר ו-returngetExtra(), totalPrice()
פקודהמשנה את מצב העצם ולא מחזירה ערךvoidפעולת set, setExtra(int minutes, int usage)

this: התכונה מול הפרמטר

כשלפרמטר יש אותו שם כמו לתכונה, this.name היא התכונה של העצם הנוכחי, ו-name לבד הוא הפרמטר.

כתובפירוש
this.name = name;התכונה מקבלת את ערך הפרמטר. נכון
name = name;הפרמטר מקבל את עצמו, והתכונה לא משתנה (נשארת null)
this.toSchool = true;תכונה שאינה פרמטר מקבלת ערך קבוע

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

מותר לכתוב יותר מפעולה בונה אחת, בתנאי שרשימות הפרמטרים שונות (העמסת פעולות בונות). new בוחרת את הפעולה הבונה לפי הערכים שמעבירים לה:

יצירההפעולה הבונה שמופעלתהעצם שנבנה
new Transport("Oz", 30, 2)Transport(String name, int num, int day) (ב-C# string)Oz, הסעה הלוך, 30 תלמידים, יום 2
new Transport(20)Transport(int num)Aviv, הסעה חזור, 20 תלמידים, יום 4
שים לב

הפעולה הבונה מאתחלת את כל התכונות, גם את אלה שלא מתקבלות כפרמטר: ב-TourPackage this.extra = 0, וב-Transport this.toSchool = true ("הסעה הלוך").

שים לב

בדיקת תקינות בפעולה בונה: "אם פרמטר מספר התלמידים (num) אינו תקין, התכונה תקבל 1". תקין הוא בין 1 ל-50, ולכן בודקים את שני הגבולות: num >= 1 && num <= 50. מי שבודק רק num > 50 משאיר בתכונה 0 או מספר שלילי.

שים לב

אם כתבתם במחלקה פעולה בונה עם פרמטרים, אין בה פעולה בונה בלי פרמטרים: new TourPackage() לא עובר הידור. המהדר מוסיף פעולה בונה בלי פרמטרים רק למחלקה שאין בה אף פעולה בונה.

שים לב

התכונות הן private. בפעולה חיצונית, מחוץ למחלקה, אי אפשר לכתוב p.extra: כותבים p.getExtra() / p.GetExtra().

דוגמה - שתי פעולות בונות למחלקת הסעות

נתונה המחלקה Transport (הסעה), ולה ארבע תכונות:

•name - שם היישוב שבעבורו מתבצעת ההסעה, מטיפוס מחרוזת
•toSchool - סוג ההסעה: true בעבור "הסעה הלוך" (מהבית לבית הספר), false בעבור "הסעה חזור"
•num - מספר התלמידים בהסעה, שלם בין 1 ל-50 (כולל)
•day - שלם בין 1 ל-6 (כולל), היום בשבוע שבו ההסעה מתבצעת (ראשון-שישי בהתאמה)

א(1). כתבו פעולה בונה במחלקה Transport, המקבלת את שם היישוב name, את מספר התלמידים num ואת היום day. הפעולה תאתחל את תכונות המחלקה. בסוג ההסעה הפעולה תיצור "הסעה הלוך". הניחו שהפרמטרים שמתקבלים תקינים.
א(2). כתבו פעולה בונה במחלקה Transport המקבלת רק את מספר התלמידים num. הפעולה תאתחל את התכונות כך שתתקבל "הסעה חזור" ביישוב Aviv ביום רביעי עם num תלמידים.
הערה: אם הפרמטר num אינו תקין, התכונה תקבל 1.

פתרון
1.התכונות: ארבע תכונות private, בשמות ובטיפוסים שבשאלה.
2.א(1): שלושה פרמטרים לשלוש תכונות, ו-toSchool מקבלת true. אין בדיקת תקינות, כי נאמר שהפרמטרים תקינים.
3.א(2): פרמטר אחד. name = "Aviv", toSchool = false, ו-day = 4: ראשון הוא 1, ולכן רביעי הוא 4.
4.num ב-א(2): אם num >= 1 && num <= 50 מציבים num, אחרת 1.
5.שתי פעולות בונות באותו שם: מותר, כי רשימות הפרמטרים שונות.
public class Transport
{
    private String name;       // שם היישוב
    private boolean toSchool;  // true = הסעה הלוך, false = הסעה חזור
    private int num;           // מספר התלמידים (1-50)
    private int day;           // יום בשבוע (1-6)

    // א(1)
    public Transport(String name, int num, int day)
    {
        this.name = name;
        this.num = num;
        this.day = day;
        this.toSchool = true;      // "הסעה הלוך"
    }

    // א(2)
    public Transport(int num)
    {
        this.name = "Aviv";
        this.toSchool = false;     // "הסעה חזור"
        this.day = 4;              // יום רביעי
        if (num >= 1 && num <= 50)
            this.num = num;
        else
            this.num = 1;
    }
}
6.בדיקה: new Transport("Oz", 30, 2) נותנת Oz, true, 30, 2. new Transport(20) נותנת Aviv, false, 20, 4. עבור 70 ועבור 0 מתקבל num = 1, ועבור 1 ועבור 50 הערך נשמר.
תשובה

א(1) this.name = name; this.num = num; this.day = day; this.toSchool = true;
א(2) name = "Aviv", toSchool = false, day = 4, ו-num אם num >= 1 && num <= 50, אחרת 1.

2. פעולות של מחלקה: פעולה פנימית ו-toString

פעולה פנימית

פעולה פנימית היא מה שהעצם "יודע לעשות". חבילת סלולר יודעת לחשב כמה לשלם על חריגה, ותוצאות של שחיין יודעות לומר אם הוא משתפר. הפעולה נכתבת בתוך המחלקה, ועובדת על התכונות של העצם שעליו הופעלה.
במדויק: פעולה פנימית נכתבת בתוך המחלקה, בלי static. היא ניגשת לתכונות ישירות (arr, this.maxTime), ויכולה לקרוא לפעולה פנימית אחרת של אותו עצם בלי לכתוב עצם לפניה (deltas(false)). היא מקבלת כפרמטר רק את מה שאין לעצם: בפעולה deltas / Deltas את isLonger, ובפעולה setExtra / SetExtra את השימוש בפועל. toString היא פעולה פנימית שמחזירה תיאור של העצם כמחרוזת.

פעולה פנימית יכולה לקבל גם עצם אחר מאותה מחלקה, כמו isLater ו-sameDate. על כך בשיעור על יצירת עצמים והפניות.

שאילתה או פקודה: איך כותבים כל אחת

סוגכותרתבגוף הפעולהדוגמה מהבגרות
שאילתהטיפוס מוחזר: int, boolean / bool, doubleמחשבים ומחזירים ב-return. לא משנים תכונותdeltas(boolean isLonger), improving(), totalPrice()
פקודהvoidמציבים ערך חדש בתכונה, למשל this.extra = sum;. אין return של ערךsetExtra(int minutes, int usage)

toString: תיאור העצם כמחרוזת

בשאלוני 899371 שבאתר (2023-2026 והבחינה לדוגמה) לא התבקשה כתיבה של toString. זו תבנית: המחלקה Birthdate בנויה על התכונות מקיץ 2026, אבל הפעולה הבונה והפעולה toString נוספו כאן ואינן בשאלון.

הפעולה מחזירה מחרוזת ולא מדפיסה. ב-C# כותבים override, אחרת הדפסת העצם לא משתמשת בפעולה שכתבתם.

public class Birthdate
{
    private int day;
    private int month;
    private int year;

    public Birthdate(int day, int month, int year)
    {
        this.day = day;
        this.month = month;
        this.year = year;
    }

    public String toString()
    {
        return this.day + "/" + this.month + "/" + this.year;
    }
}

שימוש:

Birthdate b = new Birthdate(5, 3, 2008);
System.out.println(b);              // 5/3/2008
String s = "born " + b.toString();  // "born 5/3/2008"

הדפסה של העצם עצמו, System.out.println(b) / Console.WriteLine(b), מדפיסה את מה ש-toString מחזירה: 5/3/2008.

דרך הפתרון

פקודה שמעדכנת תכונה לפי כמה תנאים

1.מתחילים מצובר 0: int sum = 0;.
2.כל רכיב בתנאי משלו: חריגה בדקות רק אם minutes > maxTime, וחריגה בגלישה רק אם usage > maxData. שני if נפרדים, בלי else, כי ייתכנו שתי החריגות יחד.
3.מציבים בתכונה בסוף: this.extra = sum;. הפעולה void, בלי return.
4.בודקים ארבעה מקרים: אין חריגה, חריגה רק בדקות, רק בגלישה, ובשתיהן.
שים לב

בלי תנאים, (minutes - maxTime) + (usage - maxData) * 2 שגוי כשאחד השימושים קטן מהחבילה: ההפרש השלילי "מקזז" את החריגה. בחבילה של 100 דקות ו-10 Giga, עם 130 דקות ו-5 Giga, יוצא 20 במקום 30.

שים לב

בפעולה deltas / Deltas הלולאה מתחילה ב-i = 1: משווים כל יום ליום שלפניו, arr[i - 1], ולראשון אין יום קודם. יום שבו הזמן לא השתנה (38 ואחריו 38) לא נספר באף אחד מהסכומים.

שים לב

"חובה להיעזר בפעולה שכתבתם בסעיף א": בתוך המחלקה קוראים לה ישירות, deltas(false) > deltas(true), בלי עצם לפניה. "גדול מ" הוא >: כשהסכומים שווים מחזירים false.

דוגמה א - סכום הפרשים בזמני שחייה ובדיקת שיפור

נתונה המחלקה Results, המייצגת זמני שחיית 50 מטרים של שחיין בתקופה מסוימת. למחלקה שתי תכונות:

•arr - מערך מטיפוס שלם, ובו מספר השניות שארכה השחייה בכל יום
•name - שם השחיין, מטיפוס מחרוזת

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

א. כתבו פעולה פנימית ששמה deltas בשפת Java או Deltas בשפת C#, המקבלת פרמטר isLonger מטיפוס בוליאני. אם isLonger הוא true, הפעולה תחזיר את סך ההפרשים בימי "הרעה"; אם הוא false - את סך ההפרשים בימי "שיפור".
ב. כתבו פעולה פנימית ששמה improving בשפת Java או Improving בשפת C#, המחזירה true אם סך ההפרשים בימי "שיפור" גדול מסך ההפרשים בימי "הרעה", אחרת false. חובה להיעזר בפעולה שכתבתם בסעיף א.

אינדקס0123456
arr45525053383842

בדוגמה, deltas(true) מחזירה 14 ו-deltas(false) מחזירה 17.

פתרון
1.א: עוברים מ-i = 1 ומשווים את arr[i] ל-arr[i - 1]. אם isLonger וגם arr[i] > arr[i - 1], מוסיפים arr[i] - arr[i - 1]. אם לא isLonger וגם arr[i] < arr[i - 1], מוסיפים arr[i - 1] - arr[i]. הפעולה פנימית, ולכן ניגשים ל-arr ישירות.
2.ב: deltas(false) הוא סך השיפור ו-deltas(true) סך ההרעה. מחזירים את ההשוואה ב->.
// א
public int deltas(boolean isLonger)
{
    int sum = 0;
    for (int i = 1; i < arr.length; i++)
    {
        if (isLonger && arr[i] > arr[i - 1])          // "הרעה"
            sum = sum + (arr[i] - arr[i - 1]);
        else if (!isLonger && arr[i] < arr[i - 1])    // "שיפור"
            sum = sum + (arr[i - 1] - arr[i]);
    }
    return sum;
}

// ב
public boolean improving()
{
    return deltas(false) > deltas(true);
}
3.בדיקה על הדוגמה:
יוםמעברסוגהפרש
145 ל-52הרעה7
252 ל-50שיפור2
350 ל-53הרעה3
453 ל-38שיפור15
538 ל-38אין שינוי-
638 ל-42הרעה4

ההרעה: 7 + 3 + 4 = 14. השיפור: 2 + 15 = 17. לכן improving מחזירה true. עבור 40, 45, 40 שני הסכומים 5, ו-improving מחזירה false.

תשובה

א. סוכמים מ-i = 1: אם isLonger ו-arr[i] > arr[i - 1] מוסיפים arr[i] - arr[i - 1]; אם לא isLonger ו-arr[i] < arr[i - 1] מוסיפים arr[i - 1] - arr[i]. בדוגמה: 14 ו-17.
ב. return deltas(false) > deltas(true);

דוגמה ב - פקודה שמחשבת תשלום על חריגה

נתונה המחלקה TourPackage (חבילת סלולר לטסים לחו"ל), ולה חמש תכונות מטיפוס שלם: id (מספר זיהוי של לקוח), price (מחיר החבילה), maxTime (מספר דקות השיחה הכלול בחבילה), maxData (נפח הגלישה ב-Giga הכלול בחבילה) ו-extra (הסכום לתשלום על חריגה). תעריפי החריגה: שקל אחד לכל דקת שיחה נוספת, ו-2 שקלים לכל Giga נוסף.
כתבו פעולה פנימית במחלקה TourPackage ששמה setExtra בשפת Java או SetExtra בשפת C#, המקבלת את מספר דקות השיחה שבהן השתמש הלקוח בפועל - minutes, ואת נפח הגלישה שבו השתמש בפועל - usage (שניהם שלמים). הפעולה קובעת ערך לתכונה extra בהתאם לחריגה מהחבילה (ככל שיש) ולתעריפי החריגה.
הערה: extra היא 0 לפני הפעולה.

פתרון
1.סוג הפעולה: פקודה. היא משנה את התכונה extra ולא מחזירה ערך, ולכן void.
2.דקות: אם minutes > maxTime, מוסיפים (minutes - maxTime) * 1.
3.גלישה: אם usage > maxData, מוסיפים (usage - maxData) * 2.
4.הצבה: this.extra = sum;. אם אין חריגה כלל, נשאר 0.
public void setExtra(int minutes, int usage)
{
    int sum = 0;
    if (minutes > this.maxTime)
        sum = sum + (minutes - this.maxTime) * 1;   // שקל לכל דקה נוספת
    if (usage > this.maxData)
        sum = sum + (usage - this.maxData) * 2;     // 2 שקלים לכל Giga נוסף
    this.extra = sum;
}
5.בדיקה: חבילה של 100 דקות ו-10 Giga, עם 130 דקות ו-12 Giga: 30 · 1 + 2 · 2 = 34. חבילה של 200 דקות ו-20 Giga, עם 150 דקות ו-20 Giga: 0. חבילה של 60 דקות ו-5 Giga: עם 60 דקות ו-8 Giga יוצא 6 (רק גלישה), ועם 75 דקות ו-1 Giga יוצא 15 (רק דקות).
תשובה

extra = החריגה בדקות (minutes - maxTime, רק אם minutes > maxTime) ועוד פעמיים החריגה בגלישה (usage - maxData, רק אם usage > maxData). למשל 34 בחבילה של 100 דקות ו-10 Giga עם 130 דקות ו-12 Giga.

3. יצירת עצמים, הפניות ושימוש בפעולות של עצם

יצירת עצם והפניה

מחלקה לבד לא עושה כלום: היא רק תבנית. כדי לעבוד צריך ליצור ממנה עצמים, וכל עצם מחזיק ערכים משלו.
במדויק: new TourPackage(111, 50, 100, 10) יוצר עצם: הפעולה הבונה בונה אותו, ו-new מחזירה הפניה אליו. המשתנה p מחזיק את ההפניה, ולא את העצם עצמו. על העצם מפעילים פעולות בנקודה: p.setExtra(130, 12), p.getExtra(). כמה עצמים מאותה מחלקה הם מופעים נפרדים של אותה תבנית, ולכל אחד ערכי תכונות משלו.

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

יצירה, זימון פעולות והפניות

על המחלקה TourPackage, עם הפעולה setExtra מקיץ 2024:

TourPackage p = new TourPackage(111, 50, 100, 10);   // יוצר עצם
p.setExtra(130, 12);                    // זימון פעולה על העצם
System.out.println(p.getExtra());       // 34

TourPackage q = p;                      // הפניה נוספת לאותו עצם
q.setExtra(100, 10);
System.out.println(p.getExtra());       // 0 - גם p השתנה

TourPackage r = new TourPackage(111, 50, 100, 10);   // עצם חדש, אותם ערכים
System.out.println(p == r);             // false - שתי הפניות שונות
System.out.println(p == q);             // true - אותו עצם
•q = p לא יוצרת עצם חדש: p ו-q מפנות לאותו עצם, ושינוי דרך q נראה גם דרך p.
•p == r משווה הפניות, ולכן false, גם כשכל התכונות שוות.
•ב-C# ערך בוליאני מודפס True / False.

גישה לתכונות: מתוך המחלקה ומחוצה לה

איפה הקודהתכונות של העצם הנוכחיהתכונות של עצם אחר
פעולה פנימיתישירות: this.hh או hhother.getHh() / other.GetHh() (מתוך אותה מחלקה מותר גם other.hh)
פעולה חיצוניתאין עצם נוכחירק דרך get ו-set: p.getExtra()
דרך הפתרון

פעולה פנימית שמשווה את העצם לעצם אחר

1.כותרת: הפרמטר מטיפוס המחלקה עצמה: isLater(Lesson other).
2.שני הצדדים: את העצם הנוכחי קוראים ישירות (this.hh), ואת other דרך get (other.getHh()).
3.כשההשוואה על כמה תכונות: ממירים למספר אחד שאפשר להשוות. שעה ודקה הופכות לדקות מחצות: hh * 60 + mm. לשוויון מלא מחברים השוואות ב-&&, כמו ב-sameDate.
4.מחזירים ביטוי בוליאני: return thisStart > otherStart;.
שים לב

hh > other.getHh() && mm > other.getMm() שגוי: עבור 13:05 לעומת 12:30 הוא נותן false, כי 5 לא גדול מ-30. משווים דקות מחצות, או: השעה גדולה, או השעה שווה והדקה גדולה.

שים לב

this == other משווה הפניות, לא תאריכים. שני עצמים נפרדים עם אותו יום, חודש ושנה אינם ==. כדי להשוות ערכים כותבים פעולה כמו sameDate.

שים לב

"מתחיל מאוחר יותר" היא השוואה חזקה, >: שיעור לעומת עצמו, או שני שיעורים שמתחילים באותה דקה, מחזירים false.

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

נתונה המחלקה Lesson (שיעור), ולה ארבע תכונות מטיפוס שלם:

•id - קוד המקצוע
•hh - השעה שבה השיעור מתחיל (בין 8 ל-17)
•mm - הדקה שבה השיעור מתחיל (בין 0 ל-59)
•duration - משך השיעור בדקות

הניחו שהפעולות get/Get ו-set/Set קיימות בעבור תכונות המחלקה.
כתבו במחלקה Lesson פעולה פנימית ששמה isLater בשפת Java או IsLater בשפת C#, המקבלת שיעור אחר - other (מטיפוס Lesson). הפעולה מחזירה true אם השיעור הנוכחי מתחיל מאוחר יותר מהזמן שבו מתחיל השיעור other, ואחרת מחזירה false.

פתרון
1.הצד של this: this.hh * 60 + this.mm - מספר הדקות מחצות.
2.הצד של other: other.getHh() * 60 + other.getMm().
3.השוואה אחת: מאוחר יותר = מספר דקות גדול יותר, בהשוואה חזקה.
public boolean isLater(Lesson other)
{
    int thisStart = this.hh * 60 + this.mm;                // דקות מחצות
    int otherStart = other.getHh() * 60 + other.getMm();
    return thisStart > otherStart;
}
4.בדיקה: 13:05 לעומת 13:00 - true. 13:00 לעומת 13:05 - false. 8:00 לעומת 10:15 - false. 13:05 לעומת 12:30 - true. שיעור לעומת עצמו - false.
תשובה

return hh * 60 + mm > other.getHh() * 60 + other.getMm();

4. מחלקה מורכבת: תכונה שהיא עצם של מחלקה אחרת

מחלקה מורכבת

ללקוח יש אותיות של שם, וגם תאריך לידה. לתאריך יש יום, חודש ושנה. במקום לשים את כל השדות ב-Client, נותנים ל-Client תכונה אחת מטיפוס Birthdate: מחלקה שכבר יודעת לטפל בתאריכים.
במדויק: מחלקה מורכבת היא מחלקה שאחת מתכונותיה היא עצם של מחלקה אחרת. למשל Client עם התכונה birthdate מטיפוס Birthdate, או Parking עם in ו-out מטיפוס MyTime. הפעולות של המחלקה המורכבת לא ניגשות לתכונות הפרטיות של העצם הפנימי: הן מפעילות את הפעולות שלו, כמו this.birthdate.sameDate(...) ו-getIn().diff(getOut()).

השאלה על מחלקה מורכבת בנויה בשכבות. קודם כותבים פעולה במחלקה הפנימית (sameDate), ואחר כך פעולה במחלקה המורכבת שמשתמשת בה (areSame). בקיץ 2026 נכתב בהנחיות שבבחינה יש שאלה אחת בלבד בנושא מחלקה מורכבת.

התבנית: תכונה מטיפוס מחלקה אחרת

התכונות של המחלקה Client מקיץ 2026. בשאלון אין פעולות בונות (נאמר רק שקיימות get ו-set), ולכן שתי הפעולות הבונות כאן הן תבנית: אחת מקבלת עצם Birthdate מוכן, והשנייה יוצרת אותו בעצמה (בעזרת הפעולה הבונה של Birthdate מהתבנית של toString):

public class Client
{
    private char firstNameInitial;
    private char lastNameInitial;
    private Birthdate birthdate;     // תכונה שהיא עצם של מחלקה אחרת

    // מקבלת עצם Birthdate שכבר נוצר
    public Client(char firstNameInitial, char lastNameInitial, Birthdate birthdate)
    {
        this.firstNameInitial = firstNameInitial;
        this.lastNameInitial = lastNameInitial;
        this.birthdate = birthdate;
    }

    // מקבלת מספרים ויוצרת בעצמה את העצם הפנימי
    public Client(char firstNameInitial, char lastNameInitial, int day, int month, int year)
    {
        this.firstNameInitial = firstNameInitial;
        this.lastNameInitial = lastNameInitial;
        this.birthdate = new Birthdate(day, month, year);
    }

    public Birthdate getBirthdate() { return this.birthdate; }
}

יצירה ושימוש:

Client c1 = new Client('D', 'C', new Birthdate(5, 3, 2008));
Client c2 = new Client('D', 'C', 5, 3, 2008);
System.out.println(c1.getBirthdate().getYear());   // 2008 - שתי נקודות: Client ואז Birthdate

שרשרת נקודות: מי מפעיל את מה

כל נקודה מפעילה פעולה של העצם שמשמאלה:

ביטוימה קורה
c1.getBirthdate()מחזיר את העצם מטיפוס Birthdate של הלקוח c1
c1.getBirthdate().getYear()מפעיל את getYear על העצם הזה. מחזיר 2008
this.birthdate.sameDate(other.getBirthdate())התאריך של העצם הנוכחי משווה את עצמו לתאריך של other
getIn().diff(getOut())זמן הכניסה מחשב את ההפרש בדקות מזמן היציאה
דרך הפתרון

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

1.מפרקים את הדרישה: "דומים" = ראשי תיבות זהים וגם תאריכי לידה זהים. כל חלק שייך למחלקה אחרת.
2.החלק של התכונות הפשוטות נכתב במחלקה המורכבת עצמה: sameInitials משווה char ל-char ב-==.
3.החלק של העצם הפנימי עובר לפעולה שלו: this.birthdate.sameDate(other.getBirthdate()). לא ניגשים ל-day, month ו-year מתוך Client.
4.מחברים לפי השאלה (&&), ומשתמשים בפעולות מהסעיפים הקודמים כפי שנדרש.
שים לב

this.birthdate == other.getBirthdate() משווה הפניות. לשני לקוחות שנולדו באותו יום יש בדרך כלל שני עצמים נפרדים, וההשוואה תחזיר false. משווים בעזרת sameDate.

שים לב

כשהשאלה נותנת ממשק של המחלקה הפנימית ("אפשר להשתמש בפעולות המחלקה בלי לממש אותן"), משתמשים בפעולות שבטבלה, כמו before ו-diff, ולא כותבים אותן מחדש.

שים לב

ב-C# המילה in שמורה. לכן בקוד C# של Parking ניגשים לזמן הכניסה דרך GetIn(), ולא בשם התכונה.

דוגמה א - לקוחות דומים: ראשי תיבות ותאריך לידה

נתונה המחלקה Birthdate (תאריך לידה), ולה שלוש תכונות מטיפוס שלם: day (היום בחודש, 1-31), month (החודש, 1-12) ו-year (השנה, מספר חיובי). הניחו שקיימות פעולות get/Get ו-set/Set לתכונות המחלקה.
א. כתבו במחלקה Birthdate פעולה פנימית ששמה sameDate בשפת Java או SameDate בשפת C#, המקבלת עצם אחר - other מטיפוס Birthdate. הפעולה מחזירה true אם תאריכי הלידה זהים, אחרת false.

נתונה המחלקה Client (לקוח), ולה שלוש תכונות:

•firstNameInitial - האות הראשונה בשם הפרטי (אות גדולה באנגלית), מטיפוס char
•lastNameInitial - האות הראשונה בשם המשפחה (אות גדולה באנגלית), מטיפוס char
•birthdate - תאריך לידה, מטיפוס Birthdate

הניחו שקיימות פעולות get/Get ו-set/Set לתכונות המחלקה.
ב(1). ראשי התיבות של שני לקוחות זהים אם גם האות הראשונה בשם הפרטי זהה וגם האות הראשונה בשם המשפחה זהה. כתבו במחלקה Client פעולה פנימית ששמה sameInitials בשפת Java או SameInitials בשפת C#, המקבלת עצם אחר - other מטיפוס Client, ומחזירה true אם ראשי התיבות זהים, אחרת false.
ב(2). שני לקוחות "דומים" אם גם ראשי התיבות שלהם זהים וגם תאריכי הלידה שלהם זהים. כתבו במחלקה Client פעולה פנימית ששמה areSame בשפת Java או AreSame בשפת C#, המקבלת עצם אחר - other מטיפוס Client, ומחזירה true אם שני הלקוחות "דומים", אחרת false. יש להשתמש בפעולות שכתבתם בסעיף א ובתת-סעיף ב(1).

פתרון
1.א: תאריכים זהים אם היום, החודש וגם השנה שווים. את התכונות של this קוראים ישירות, ואת של other דרך get.
2.ב(1): התכונות מטיפוס char, ולכן משווים ב-== ומחברים ב-&&.
3.ב(2): birthdate היא עצם, ולכן את השוואת התאריכים מעבירים לפעולה שלו: this.birthdate.sameDate(other.getBirthdate()). מחברים עם sameInitials(other).
// א - במחלקה Birthdate
public boolean sameDate(Birthdate other)
{
    return this.day == other.getDay() &&
           this.month == other.getMonth() &&
           this.year == other.getYear();
}
// ב(1) - במחלקה Client
public boolean sameInitials(Client other)
{
    return this.firstNameInitial == other.getFirstNameInitial() &&
           this.lastNameInitial == other.getLastNameInitial();
}

// ב(2) - במחלקה Client
public boolean areSame(Client other)
{
    return this.sameInitials(other) &&
           this.birthdate.sameDate(other.getBirthdate());
}
4.בדיקה: 5/3/2008 מול 5/3/2008 - true; מול 5/4/2008 - false; מול 5/3/2009 - false. הלקוחות D.C 5/3/2008 ו-D.C 5/3/2008 דומים (true), גם כששני עצמי ה-Birthdate שלהם נפרדים. D.C 5/3/2008 מול D.K 5/3/2008 - false (ראשי תיבות), ומול D.C 5/4/2008 - false (תאריך).
תשובה

א. return day == other.getDay() && month == other.getMonth() && year == other.getYear();
ב(1) return firstNameInitial == other.getFirstNameInitial() && lastNameInitial == other.getLastNameInitial();
ב(2) return sameInitials(other) && birthdate.sameDate(other.getBirthdate());

דוגמה ב - משך חניה בעזרת ממשק של MyTime

המחלקה MyTime מייצגת זמן, ולה שתי תכונות: myMinute (דקה, 0-59) ו-myHour (שעה, 7-23). הניחו שקיימות פעולות get/Get ו-set/Set ופעולה בונה. לפניכם ממשק המחלקה. אפשר להשתמש בפעולות המחלקה בלי לממש אותן.

כותרת הפעולה (Java / C#)תיאור
public boolean before(MyTime other) / public bool Before(MyTime other)מחזירה true אם זמן העצם הנוכחי מוקדם מזמן העצם other, אחרת false
public int diff(MyTime other) / public int Diff(MyTime other)מחזירה את ההפרש בדקות, בערך מוחלט, בין זמן העצם הנוכחי לזמן העצם other

המחלקה Parking מציגה מידע על מכונית שחנתה בחניון, ולה שלוש תכונות: id (מספר לוחית רישוי, מחרוזת), in (זמן הכניסה, מטיפוס MyTime) ו-out (זמן היציאה, מטיפוס MyTime). הניחו שקיימות פעולות get/Get ו-set/Set, ושהתכונות אינן null.
כתבו פעולה פנימית במחלקה Parking ששמה total בשפת Java או Total בשפת C#, המחזירה את מספר הדקות שהמכונית חנתה בחניון.

פתרון
1.מה צריך: ההפרש בדקות בין זמן הכניסה לזמן היציאה.
2.מי יודע לחשב: הפעולה diff של MyTime, מהממשק הנתון. לא מממשים אותה.
3.הפעלה: מפעילים את diff על זמן הכניסה, וזמן היציאה הוא הפרמטר. ב-C# in היא מילה שמורה, ולכן נוח לכתוב GetIn().
// במחלקה Parking
public int total()
{
    return getIn().diff(getOut());
}
4.בדיקה: כניסה 09:30 ויציאה 10:15 - 45. כניסה 13:20 ויציאה 23:59 - 639.
תשובה

return getIn().diff(getOut());

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

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

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