מחלקה, עצם ומצב העצם
עד עכשיו עבדתם עם טיפוסים מוכנים כמו 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) |
| שאילתה | מחזירה ערך ולא משנה את מצב העצם | טיפוס מוחזר ו-return | getExtra(), 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 (הסעה), ולה ארבע תכונות:
א(1). כתבו פעולה בונה במחלקה Transport, המקבלת את שם היישוב name, את מספר התלמידים num ואת היום day. הפעולה תאתחל את תכונות המחלקה. בסוג ההסעה הפעולה תיצור "הסעה הלוך". הניחו שהפרמטרים שמתקבלים תקינים.
א(2). כתבו פעולה בונה במחלקה Transport המקבלת רק את מספר התלמידים num. הפעולה תאתחל את התכונות כך שתתקבל "הסעה חזור" ביישוב Aviv ביום רביעי עם num תלמידים.
הערה: אם הפרמטר num אינו תקין, התכונה תקבל 1.
private, בשמות ובטיפוסים שבשאלה.name = "Aviv", toSchool = false, ו-day = 4: ראשון הוא 1, ולכן רביעי הוא 4.num >= 1 && num <= 50 מציבים num, אחרת 1.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;
}
}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.
פקודה שמעדכנת תכונה לפי כמה תנאים
int sum = 0;.minutes > maxTime, וחריגה בגלישה רק אם usage > maxData. שני if נפרדים, בלי else, כי ייתכנו שתי החריגות יחד.this.extra = sum;. הפעולה void, בלי return.בלי תנאים, (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 מטרים של שחיין בתקופה מסוימת. למחלקה שתי תכונות:
"הרעה" היא יום שבו השחייה ארכה יותר שניות מביום הקודם, ו"שיפור" הוא יום שבו ארכה פחות שניות מביום הקודם. "הפרש" הוא ההבדל במספר השניות, בערך מוחלט, בין יום ליום שקדם לו.
א. כתבו פעולה פנימית ששמה deltas בשפת Java או Deltas בשפת C#, המקבלת פרמטר isLonger מטיפוס בוליאני. אם isLonger הוא true, הפעולה תחזיר את סך ההפרשים בימי "הרעה"; אם הוא false - את סך ההפרשים בימי "שיפור".
ב. כתבו פעולה פנימית ששמה improving בשפת Java או Improving בשפת C#, המחזירה true אם סך ההפרשים בימי "שיפור" גדול מסך ההפרשים בימי "הרעה", אחרת false. חובה להיעזר בפעולה שכתבתם בסעיף א.
| אינדקס | 0 | 1 | 2 | 3 | 4 | 5 | 6 |
|---|---|---|---|---|---|---|---|
| arr | 45 | 52 | 50 | 53 | 38 | 38 | 42 |
בדוגמה, deltas(true) מחזירה 14 ו-deltas(false) מחזירה 17.
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 ישירות.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);
}| יום | מעבר | סוג | הפרש |
|---|---|---|---|
| 1 | 45 ל-52 | הרעה | 7 |
| 2 | 52 ל-50 | שיפור | 2 |
| 3 | 50 ל-53 | הרעה | 3 |
| 4 | 53 ל-38 | שיפור | 15 |
| 5 | 38 ל-38 | אין שינוי | - |
| 6 | 38 ל-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 לפני הפעולה.
void.minutes > maxTime, מוסיפים (minutes - maxTime) * 1.usage > maxData, מוסיפים (usage - maxData) * 2.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;
}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, גם כשכל התכונות שוות.True / False.גישה לתכונות: מתוך המחלקה ומחוצה לה
| איפה הקוד | התכונות של העצם הנוכחי | התכונות של עצם אחר |
|---|---|---|
| פעולה פנימית | ישירות: this.hh או hh | other.getHh() / other.GetHh() (מתוך אותה מחלקה מותר גם other.hh) |
| פעולה חיצונית | אין עצם נוכחי | רק דרך get ו-set: p.getExtra() |
פעולה פנימית שמשווה את העצם לעצם אחר
isLater(Lesson other).this.hh), ואת other דרך get (other.getHh()).hh * 60 + mm. לשוויון מלא מחברים השוואות ב-&&, כמו ב-sameDate.return thisStart > otherStart;.hh > other.getHh() && mm > other.getMm() שגוי: עבור 13:05 לעומת 12:30 הוא נותן false, כי 5 לא גדול מ-30. משווים דקות מחצות, או: השעה גדולה, או השעה שווה והדקה גדולה.
this == other משווה הפניות, לא תאריכים. שני עצמים נפרדים עם אותו יום, חודש ושנה אינם ==. כדי להשוות ערכים כותבים פעולה כמו sameDate.
"מתחיל מאוחר יותר" היא השוואה חזקה, >: שיעור לעומת עצמו, או שני שיעורים שמתחילים באותה דקה, מחזירים false.
דוגמה - האם שיעור מתחיל מאוחר יותר משיעור אחר
נתונה המחלקה Lesson (שיעור), ולה ארבע תכונות מטיפוס שלם:
הניחו שהפעולות get/Get ו-set/Set קיימות בעבור תכונות המחלקה.
כתבו במחלקה Lesson פעולה פנימית ששמה isLater בשפת Java או IsLater בשפת C#, המקבלת שיעור אחר - other (מטיפוס Lesson). הפעולה מחזירה true אם השיעור הנוכחי מתחיל מאוחר יותר מהזמן שבו מתחיל השיעור other, ואחרת מחזירה false.
this.hh * 60 + this.mm - מספר הדקות מחצות.other.getHh() * 60 + other.getMm().public boolean isLater(Lesson other)
{
int thisStart = this.hh * 60 + this.mm; // דקות מחצות
int otherStart = other.getHh() * 60 + other.getMm();
return thisStart > otherStart;
}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()) | זמן הכניסה מחשב את ההפרש בדקות מזמן היציאה |
פעולה במחלקה המורכבת
==.this.birthdate.sameDate(other.getBirthdate()). לא ניגשים ל-day, month ו-year מתוך Client.&&), ומשתמשים בפעולות מהסעיפים הקודמים כפי שנדרש.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 (לקוח), ולה שלוש תכונות:
הניחו שקיימות פעולות 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).
== ומחברים ב-&&.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());
}א. 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#, המחזירה את מספר הדקות שהמכונית חנתה בחניון.
in היא מילה שמורה, ולכן נוח לכתוב GetIn().// במחלקה Parking
public int total()
{
return getIn().diff(getOut());
}return getIn().diff(getOut());