Transcript JAVA

‫‪© Keren Kalif‬‬
‫תכנות מכוון עצמים ושפת ‪JAVA‬‬
‫תוספות בשפת ‪JAVA‬‬
‫קרן כליף‬
2
© Keren Kalif
:‫ביחידה זו נלמד‬
JoptionPane
String ‫המחלקה‬
Date ‫המחלקה‬
‫מחלקה פנימית‬
Object ‫המחלקה‬
‫ממשקים‬
‫אוספים‬
static c’tor








‫קליטת נתונים‪JOptionPane :‬‬
‫שיטה לקבלת נתון מסוג ‪String‬‬
‫שיטה להצגת טקסט‪ ,‬כותרת וכפתורים‬
‫‪3‬‬
‫‪© Keren Kalif‬‬
© Keren Kalif
Date -‫ ו‬String ‫המחלקות‬
‫המחלקה ‪String‬‬
‫‪ ‬כאשר רצינו להגדיר משתנה מטיפוס מחרוזת בשפת ‪ C‬הגדרנו‬
‫מערך של תווים‪ ,‬הגבלנו אותו הגודל‪ ,‬או שהקצנו דינאמית‬
‫‪ ‬בשפת ‪ JAVA‬יש את המחלקה ‪ String‬שמחזיקה מחרוזת‪ ,‬ואינה‬
‫מוגבלת בכמות התווים‬
‫‪ ‬המחלקה יודעת לנהל זאת בעצמה‬
‫‪ ‬המחלקה ‪ String‬היא מחלקה מיוחדת מאחר ולא ניתן לשנות את‬
‫ערכם של האובייקטים‬
‫‪ ‬כל שינוי האובייקט יוצר למעשה אובייקט חדש‪immutable ,‬‬
‫‪5‬‬
‫‪© Keren Kalif‬‬
‫דוגמא‬
‫‪X1 = 53‬‬
‫‪X2 = 5‬‬
‫‪F‬‬
‫‪T‬‬
‫)‪str1 = “hello world” (id=24‬‬
‫)‪(id=22‬‬
‫”“ = ‪str2‬‬
‫‪“hello‬‬
‫)‪(id=23‬‬
‫)‪world” (id=24‬‬
‫‪T‬‬
‫‪F‬‬
‫‪T‬‬
‫‪T‬‬
‫ה‪ id -‬של משתנה מטיפוס ‪String‬‬
‫משתנה כאשר משנים את ערכו‬
‫השמה בין ‪ 2‬אובייקטים תפנה לאותו‬
‫מקום‪ ,‬כלומר יהיה להם ‪ id‬זהה‬
‫‪6‬‬
‫‪© Keren Kalif‬‬
‫בדיקת שוויון עבור אובייקטים באמצעות ==‬
‫בודקת את ההפניה‪ ,‬כלומר האם ה‪ id -‬זהה‪.‬‬
‫בדיקת שוויון באמצעות ‪ equals‬בודקת את התוכן‪.‬‬
‫המחלקה ‪StringBuffer‬‬
‫‪ ‬העבודה עם אובייקטים ממחלקת ‪ String‬שיש לשנותם יקרה‬
‫מבחינת ביצועים‪ ,‬כי כל עדכון באובייקט גורר יצירת אובייקט חדש‬
‫‪ ‬המחלקה ‪ StringBuffer‬משמשת גם היא לאיכסון מחרוזות‪ ,‬אך‬
‫היא יותר יעילה מבחינת ביצועים כאשר רוצים לעבוד עם מחרוזת‬
‫שמשנים את ערכה לעיתים תכופות‬
‫‪ ‬קיימת גם המחלקה ‪ StringBuilder‬שמאוד דומה בממשק שלה ל‪-‬‬
‫‪ ,StringBuffer‬אך היא אינה ‪.thread safe‬‬
‫תזכורת‪ :‬שיטות המחלקה ‪ String‬ושימושן הוא ללימוד עצמי!‬
‫מומלץ גם להכיר את שיטות המחלקה ‪.StringBuffer‬‬
‫‪7‬‬
‫‪© Keren Kalif‬‬
‫המחלקה ‪Date‬‬
‫‪ ‬בשפת ‪ JAVA‬קיימת המחלקה ‪ Date‬המחזיקה נתוני תאריך‬
‫‪ ‬כדי שמחלקה זו תהייה זמינה יש להוסיף בראש התוכנית‪:‬‬
‫;‪import java.util.Date‬‬
‫‪ ‬מחלקה זו מכילה ‪ 2‬שדות‪:‬‬
‫‪ ‬מספר אלפיות השניה מאז ה‪ 1.1.1970 -‬בשעה ‪00:00‬‬
‫‪ ‬שדה מטיפוס ‪ Calendar‬המייצג את השעון המקומי‬
‫‪ ‬למחלקה יש ‪ Default C’tor‬המאתחל את האובייקט עם הרגע‬
‫הנוכחי‬
‫‪ ‬היה נחמד אם למחלקה זו היה ‪ c’tor‬המקבל יום‪ ,‬חודש ושנה‬
‫‪ ‬אבל אין‪...‬‬
‫‪8‬‬
‫‪© Keren Kalif‬‬
‫דוגמא‬
‫‪9‬‬
‫במחלקה ‪ Date‬יש שיטות ישנות והקומפיילר מתריע על כך‪:‬‬
‫• קו צהוב מתחת לשיטה כאינדיקציה לכך שיש אזהרה כלשהי‬
‫• קו שחור על שם השיטה כאינדיקציה לכך שהשיטה ישנה )‪(deprecated‬‬
‫‪© Keren Kalif‬‬
‫איתחול נתוני אובייקט ‪Date‬‬
‫‪ ‬כדי לאתחל משתנה מטיפוס ‪ Date‬יש לבצע את הפעולות הבאות‪:‬‬
‫הגדר משתנה מטיפוס ‪Calendar‬‬
‫באופן הבא (בהמשך יהיה הסבר‬
‫לגבי צורת כתיבה זו)‪:‬‬
‫אתחל משתנה זה עם התאריך‬
‫המבוקש‪ .‬שימו לב שספירת‬
‫החודשים מתחילה מ‪!0 -‬‬
‫קבלת אובייקט ‪ Date‬מהמשתנה מטיפוס‬
‫‪ Calendar‬באמצעות השיטה ‪getTime‬‬
‫‪10‬‬
‫‪© Keren Kalif‬‬
‫שיטות נוספות במחלקה ‪Date‬‬
‫‪ ‬שיטות ‪ get‬ו‪ set -‬לכל אחת מתכונות המחלקה‬
‫‪ ‬שיטות השוואה מול אובייקט אחר מטיפוס ‪:Date‬‬
‫‪ – after ‬מקבלת ‪ Date‬נוסף כפרמטר ומחזירה ‪ true‬אם התאריך‬
‫המיוצג ע"י האובייקט המפעיל הוא אחרי התאריך המיוצג‬
‫ע"י הפרמטר‬
‫‪ – before ‬מקבלת ‪ Date‬נוסף כפרמטר ומחזירה ‪ true‬אם התאריך‬
‫המיוצג ע"י האובייקט המפעיל הוא לפני התאריך המיוצג‬
‫ע"י הפרמטר‬
‫‪ - compareTo ‬מקבלת ‪ Date‬נוסף כפרמטר ומחזירה ‪ 0‬אם הם‬
‫שווים‪ -1 ,‬אם התאריך המיוצג ע"י האובייקט המפעיל קטן‬
‫מהפרמטר‪ ,‬ו‪ 1 -‬אם ההיפך‬
‫‪11‬‬
‫‪© Keren Kalif‬‬
‫דוגמאות‬
© Keren Kalif
12
‫מחלקה להדפסת נתוני ‪Date‬‬
‫אובייקט המגדיר את פורמט‬
‫הדפסת התאריך בהמשך‬
‫מחזיר מחרוזת עם נתוני‬
‫התאריך בפורמט שהוגדר‬
‫‪13‬‬
‫‪© Keren Kalif‬‬
‫ירושה מהמחלקה ‪Date‬‬
‫‪ ‬אחת הסיבות לירושה היא כאשר יש לנו מחלקה שהיא כמעט‬
‫מתאימה לנו ואנחנו רוצים לממש אותה קצת שונה‬
‫‪ ‬ניתן לרשת מהמחלקה ‪ Date‬המוגדרת ב‪ java.util -‬ולאפשר את‬
‫הדברים הבאים‪:‬‬
‫‪ c’tor ‬המקבל יום‪ ,‬חודש ושנה‬
‫‪ ‬שיטות ‪ set‬ו‪ get -‬שיחזירו את השנה האמיתית (כלומר‪)+1900 ,‬‬
‫‪ ‬שיטות ‪ set‬ו‪ get -‬שיחזירו את החודש האמיתי (כלומר‪)+1 ,‬‬
‫‪ ‬דרישת השיטה ‪ toString‬שתחזיר את התאריך בצורה מקוצרת‬
‫‪14‬‬
‫‪© Keren Kalif‬‬
‫מימוש מחלקת‬
‫‪ Date‬המשופרת‬
‫‪15‬‬
‫‪© Keren Kalif‬‬
‫שימוש במחלקה החדשה‬
‫‪16‬‬
‫‪© Keren Kalif‬‬
‫‪© Keren Kalif‬‬
‫מחלקה פנימית‬
‫מחלקה פנימית )‪(Inner/Nested class‬‬
‫‪ ‬בשפת ‪ JAVA‬ניתן להגדיר מחלקה בתוך מחלקה‪.‬‬
‫‪ ‬המחלקה הפנימית יכולה לגשת לתכונות המחלקה החיצונית‪.‬‬
‫‪ ‬נשתמש כאשר יש משמעות למחלקה הפנימית רק בהקשר של‬
‫המחלקה החיצונית‪.‬‬
‫‪ ‬למשל‪ :‬המחלקה ‪ Item‬בתוך ‪ :LinkedList‬אין משמעות ל‪ Item -‬ללא‬
‫רשימה מקושרת‪.‬‬
‫‪18‬‬
‫‪© Keren Kalif‬‬
‫דוגמא‪ :‬מחלקה פנימית‬
‫המחלקה הפנימית יכולה‬
‫לגעת בתכונות ובשיטות של‬
‫המחלקה החיצונית‬
‫יצירת אובייקט מהמחלקה‬
‫הפנימית יהייה אך ורק באמצעות‬
‫אובייקט של המחלקה החיצונית‪,‬‬
‫מאחר והוא צריך גישה לאובייקט‬
‫חיצוני ספציפי‬
‫דוגמא נוספת‬
‫מחלקה פנימית‬
‫המחלקה הפנימית‬
‫יכולה לגשת לתכונות‬
‫שבמחלקה החיצונית‬
‫‪20‬‬
‫‪© Keren Kalif‬‬
‫שימוש‬
‫ניתן להגדיר משתנה‬
‫מהמחלקה הפנימית‬
‫רק באמצעות אובייקט‬
‫מהמחלקה החיצונית‬
‫הפעלת שיטה הפונה‬
‫לתכונה במחלקה החיצונית‬
‫‪21‬‬
‫‪© Keren Kalif‬‬
‫מחלקה פנימית (המשך)‬
‫‪ ‬ראינו כי מאחר והמחלקה הפנימית יכולה לגעת במשתני המחלקה‬
‫החיצונית‪ ,‬לא ניתן לייצר אובייקט מחוץ למחלקה מטיפוס המחלקה‬
‫הפנימית‪.‬‬
‫‪ ‬ייתכן והמחלקה הפנימית תוגדר כסטטית ואז ניתן יהיה לייצר‬
‫אובייקט שלה מחוץ למחלקה‪.‬‬
‫‪ ‬שימושי עבור הגדרת קבועים‬
‫‪22‬‬
‫‪© Keren Kalif‬‬
© Keren Kalif
Object ‫המחלקה‬
‫תזכורת למחלקות בהן נשתמש‬
Person
#name : string
#id : int
+Person(in name : string, in id : int)
+toString()
+getName()
Student
-average : float
+Student(in id : int, in name : string, in average : float)
+toString()
+registerToCorse()
+printSchedule()
© Keren Kalif
24
25
© Keren Kalif
...‫תזכורת‬
public static void main(String[] args)
{
Person[] persons = new Person[3];
persons[0] = new Person(111, "momo");
persons[1] = new Student(222, "gogo", 92.7f);
persons[2] = new Person(333, "yoyo");
for (int i = 0; i < persons.length; i++)
{
System.out.println(persons[i].toString());
}
}
‫ של האובייקט בפועל‬toString ‫תמיד תקרא‬
‫המחלקה ‪object‬‬
‫‪ ‬המחלקה ‪ Object‬ב‪ JAVA -‬אינה מכילה תכונות‪ ,‬אלא אוסף‬
‫שיטות בסיסיות‪ ,‬שמתוכן נתמקד ב‪ 3 -‬שהיה נחמד אם הן היו לכל‬
‫אובייקט‪:‬‬
‫‪equals, getClass, toString ‬‬
‫‪ ‬ב‪ JAVA -‬כל מחלקה שאינה יורשת ממחלקה מסוימת‪ ,‬יורשת‬
‫מהמחלקה ‪ ,Object‬גם ללא ציון מפורש של ירושה‬
‫‪ ‬כלומר‪ ,‬כל מחלקה יורשת‬
‫בסופו של דבר מ‪Object -‬‬
‫‪ ‬לכן כל פעם שנפתחה לנו רשימת השיטות של אובייקט מסוים‬
‫ראינו גם את שיטות אלו‬
‫‪26‬‬
‫‪© Keren Kalif‬‬
‫המחלקה ‪object‬‬
‫‪27‬‬
‫‪© Keren Kalif‬‬
‫ליד כל שיטה ניתן לראות באיזו‬
‫מחלקה נמצא המימוש בו‬
‫הקומפיילר ישתמש‬
‫השיטה ‪toString‬‬
‫‪ ‬שיטה זו אינה מקבלת פרמטרים ומחזירה את השם המלא של‬
‫הטיפוס ממנו נוצר האובייקט‬
‫‪ ‬למשל‪ ,‬עבור המחלקה ‪:Person‬‬
‫)‪public static void main(String[] args‬‬
‫{‬
‫;)"‪Person p = new Person(111, "momo‬‬
‫;))(‪System.out.println(p.toString‬‬
‫הדפסה של אובייקט תפעיל את‬
‫השיטה ‪ toString‬באופן אוטומטי‪,‬‬
‫לכן שתי השורות הנ"ל שקולות‬
‫‪28‬‬
‫‪© Keren Kalif‬‬
‫;)‪System.out.println(p‬‬
‫}‬
‫דריסת השיטה ‪toString‬‬
‫‪ ‬השיטה ‪ toString‬נועדה להידרס (‪ )override‬ע"י מחלקה יורשת‬
‫ולהחזיר מחרוזת המייצגת את נתוני האובייקט‬
‫‪ ‬עד היום עשינו זאת ע"י כתיבת השיטה ‪ ,toString‬אך לא ידענו‬
‫שאנחנו דורסים שיטה שמומשה בבסיס‬
‫‪ ‬השימוש ימשיך להיות זהה‬
‫‪ ‬דוגמא עבור המחלקה ‪:Person‬‬
‫מימוש בתוך המחלקה‬
‫{ )‪public static void main(String[] args‬‬
‫;)"‪Person p1 = new Person(111, "momo‬‬
‫;))(‪System.out.println(p1.toString‬‬
‫}‬
‫‪29‬‬
‫‪© Keren Kalif‬‬
‫{ )(‪public String toString‬‬
‫;‪return "Id: " + id + "\tName: " + name‬‬
‫}‬
‫השיטה ‪getClass‬‬
‫‪ ‬שיטה זו מחזירה אובייקט מטיפוס ‪ Class‬המכיל נתונים על‬
‫המחלקה‬
‫‪ ‬לא ניתן לדרוס שיטה זו (מוגדרת כ‪)final -‬‬
‫‪ ‬האובייקט ‪ Class‬מכיל שיטות עם נתונים על המחלקה עצמה‬
‫למשל‪:‬‬
‫‪ :getName ‬שיטה המחזירה את שם המחלקה‬
‫‪ :getSuperClass ‬מחזירה אובייקט מטיפוס ‪ Class‬על האבא‬
‫‪30‬‬
‫‪© Keren Kalif‬‬
‫דוגמא‬
© Keren Kalif
31
equals ‫השיטה‬
‫ (ולכן יכולה‬object ‫ מקבלת כפרמטר איזשהו אובייקט ממחלקת‬
‫ אם שניהם מצביעים לאותו‬true ‫ ומחזירה‬,)‫לקבל כל אובייקט‬
.‫ אחרת‬false ,‫אובייקט‬
id=111
name=“momo”
id=111
name=“momo”
public static void main(String[] args) {
Person p1 = new Person(111, "momo");
Person p2 = new Person(111, "momo");
Person p3 = p1;
System.out.println("p1 equals p2? “ + p1.equals(p2));
System.out.println("p1 equals p3? “ + p1.equals(p3));
System.out.println("p2 equals p3? “ + p2.equals(p3));
}
equals ‫מימוש השיטה‬
== ‫למעשה זהה לאופרטור‬
‫ ולא בתוכן‬,‫הבודק שוויון בין הפניות‬
© Keren Kalif
F
T
F
32
‫דריסת השיטה ‪equals‬‬
‫‪ ‬ראינו כי מימוש ה‪ default -‬של השיטה ‪ equals‬בודק האם‬
‫ההפניות של ‪ 2‬אובייקטים זהות‬
‫‪ ‬השיטה ‪ equals‬נועדה להידרס ע"י המחלקה היורשת ולבדוק האם‬
‫ערכי תכונות האובייקט שהועבר כפרמטר זהות לערכי התכונות של‬
‫‪ ,this‬ולא לבדוק רק הפניות‬
‫‪33‬‬
‫‪© Keren Kalif‬‬
‫דריסת השיטה ‪ – equals‬דוגמת מימוש למחלקה‬
‫‪Person‬‬
‫‪ ‬השיטה מקבלת פרמטר מטיפוס ‪ ,Object‬כלומר בפועל ניתן‬
‫להעביר פרמטר מכל טיפוס‬
‫הפרמטר שהשיטה מקבלת‬
‫במידה ו‪ other -‬אינו מסוג כלשהו של‬
‫‪ Person‬התשובה תהייה ‪ ,false‬שכן במקרה‬
‫זה ברור ש‪ other -‬ו‪ this -‬אינם זהים‪.‬‬
‫{‬
‫שם השיטה הנדרסת‬
‫)‪public boolean equals(Object other‬‬
‫))‪if (!(other instanceof Person‬‬
‫;‪return false‬‬
‫מאחר ו‪ other -‬הוא הפניה של ‪,Object‬‬
‫;‪Person p = (Person)other‬‬
‫אין לו את התכונות של ‪ ,Person‬ולכן צריך‬
‫;)‪return p.id == id && p.name.equals(name‬‬
‫לעשות ‪.casting‬‬
‫}‬
‫נחזיר את תשובת שוויון ערכי התכונות‬
‫‪34‬‬
‫‪© Keren Kalif‬‬
‫ – דוגמת מימוש‬equals ‫דריסת השיטה‬
Student ‫למחלקה‬
public boolean equals(Object other) {
if (!(other instanceof Student))
return false;
if (!(super.equals(other)) )
return false;
Student s = (Student)other;
return average == s.average;
‫ שיבצע את‬Person ‫ של‬equals -‫חלק זה קורא ל‬
.‫הבדיקה על שדות הבסיס‬
‫ ישר ניתן לדעת‬,‫במידה ואין שוויון בערכי תכונות הבסיס‬
.false ‫שהאובייקטים אינם זהים ונחזיר‬
Student ‫ נבדוק את השדות הנוספים של‬,‫אחרת‬
}
© Keren Kalif
35
‫ – דוגמת שימוש‬equals ‫דריסת השיטה‬
id=111
public static void main(String[] args) {
name=“momo”
Person p1 = new Person(111, "momo");
Person p2 = new Person(111, "momo");
Person p3 = p1;
id=111
name=“momo”
System.out.println("p1 == p2? “ + )p1==p2));
System.out.println("p1 == p3? “ + )p1==p3));
System.out.println("p2 == p3? “ + )p2==p3));
F
T
F
System.out.println("p1 equals p2? “ + p1.equals(p2));
System.out.println("p1 equals p3? “ + p1.equals(p3));
System.out.println("p2 equals p3? “ + p2.equals(p3));
T
T
T
}
© Keren Kalif
36
‫השיטה ‪ equals‬והשיטה ‪Arrays.equals‬‬
‫‪ ‬שיטה זו מקבלת ‪ 2‬מערכים ובודקת האם הם שווים‪:‬‬
‫‪ ‬האם אורך ‪ 2‬המערכים זהים והאם האיברים במקומות המתאימים‬
‫זהים‬
‫‪ ‬כדי לבדוק אם האיברים במקומות המתאימים זהים השיטה משתמשת‬
‫בשיטה ‪ equals‬של כל איבר‬
‫‪ ‬במידה ולא מומשה השיטה ‪ equals‬יש שימוש באופרטור == (שהוא‬
‫מימוש ברירת‪-‬המחדל של ‪)equals‬‬
‫כאשר אין מימוש לשיטה ‪equals‬‬
‫ב‪ Point -‬יודפס ‪,false‬‬
‫מאחר וההפניות שונות‪.‬‬
‫כאשר יש מימוש יודפס ‪,true‬‬
‫כי ערכי האובייקטים זהים‪.‬‬
‫‪37‬‬
‫‪© Keren Kalif‬‬
‫השיטה ‪hashCode‬‬
‫‪38‬‬
‫‪ ‬נועדה להחזיר מספר המזהה את האובייקט באופן חד‪-‬חד ערכי‬
‫‪ ‬בעלי ערכי תכונות זהים צריכים להחזיר ערך זהה של ‪hashCode‬‬
‫‪ ‬בשימוש בעיקר במבני נתונים שרוצים לשמור את האובייקט‬
‫כמפתח‪ ,‬מטעמי יעילות!‬
‫‪ ‬במקום לבדוק שוויון עבור כל אחד מהשדות‪ ,‬משווים את ערכו של ה‪-‬‬
‫‪hashCode‬‬
‫‪ ‬פעולה המשלימה לאובייקטים לפעולת ה‪equals -‬‬
‫דוגמאת מימוש‬
‫‪39‬‬
Object ‫מערך שאיבריו‬
-‫ היא המכנה המשותף לכל המחלקות ב‬Object ‫ מאחר והמחלקה‬
‫ בזמן‬,‫ ניתן להגדיר מערך שכל איבר בו מטיפוס שונה‬,JAVA
Object -‫שההפניות יהיו ל‬
public static void main(String[] args) {
Object[] arr = new Object[3];
arr[0] = 5;
arr[1] = "hi";
arr[2] = new Person(111, "momo");
for (int i = 0; i < arr.length; i++) {
System.out.println)"arr[“ + i + “] is of type “ + arr[i].getClass)(.getName)((;
}
}
© Keren Kalif
40
© Keren Kalif
‫ממשקים‬
‫מהו ממשק )‪?(Interface‬‬
‫‪ ‬ממשק הוא מחלקה אבסטרקטית ללא תכונות‪ ,‬וכל השיטות‬
‫אבסטרקטיות‪ ,‬כלומר רק חתימות‪ ,‬ללא מימושים‬
‫‪ ‬שם ממשק נהוג שיסתיים ב‪able -‬‬
‫‪ ‬למשל‪Comparable, Clonable, Printable :‬‬
‫‪ ‬יש סגנונות כתיבה ששם הממשק מתחיל ב‪ ,I -‬למשל ‪IPrintable‬‬
‫‪ ‬ממשק מכיל אוסף התנהגויות בעלי מכנה משותף‬
‫‪ ‬למשל גם ‪ Person‬וגם ‪ Circle‬יודעים להדפיס את עצמם‪ ,‬כלומר שניהם‬
‫ניתנים להצגה‪ ,‬כלומר ‪ .Printable‬האם זה נכון להגיד שאדם הוא סוג‬
‫‪ ?Printable‬לא‪ ,‬וכנ"ל גם ‪ Circle‬ולכן אין זו ירושה‪.‬‬
‫‪42‬‬
‫‪© Keren Kalif‬‬
‫דוגמא‪ :‬הממשק ‪IPrintable‬‬
‫המחלקה מוגדרת כ‪interface -‬‬
‫ואין ציון הרשאה ליד השיטות‬
‫ציון מימוש הממשק‬
‫מימוש השיטה‬
‫המוגדרת בממשק‬
‫‪43‬‬
‫‪© Keren Kalif‬‬
)2( IPrintable ‫ הממשק‬:‫דוגמא‬
© Keren Kalif
44
)3( IPrintable ‫ הממשק‬:‫דוגמא‬
© Keren Kalif
45
‫ה‪main -‬‬
‫הגדרת איבר המערך כ‪-‬‬
‫‪ IPrintable‬תאפשר לנו‬
‫בהמשך לקרוא לשיטה‬
‫‪ print‬ללא ‪casting‬‬
‫‪46‬‬
‫‪© Keren Kalif‬‬
‫תחביר‬
‫‪ ‬במקום להגדיר את המחלקה כ‪ abstract class -‬ניתן להגדיר‬
‫אותה כ‪( interface -‬וכך נעשה!)‬
‫‪ ‬מאחר ונגדיר את המחלקה כ‪ interface -‬ולא כ‪ ,class -‬אין חובה‬
‫לציין שהשיטות הן ‪ public‬ו‪ ,abstract -‬הקומפיילר יודע להתייחס‬
‫אליהן כך אוטומטית‬
‫‪ ‬כאשר מממשים ממשק יש להשתמש במילה ‪implements‬‬
‫‪ ‬כאשר יורשים ממשק ומחלקה‪ ,‬הממשק יבוא לאחר המחלקה‬
‫‪47‬‬
‫‪© Keren Kalif‬‬
‫דוגמא‪ :‬המחלקה ‪ Animal‬והממשק ‪INoiseable‬‬
‫‪ ‬לא כל החיות משמיעות קול‪ ,‬לכן לא נרצה לאפשר שירות זה עם‬
‫מימוש ריק במחלקת הבסיס ‪Animal‬‬
‫‪ ‬מאחר והתוספת לחיות שעושות קולות הינה התנהגותית‪ ,‬נייצר‬
‫ממשק שמכיל את היכולת ‪getNoise‬‬
‫‪ ‬חיות שיודעות להשמיע קול ירשו מ‪ Animal -‬ויממשו את הממש‬
‫‪INoiseable‬‬
‫‪48‬‬
‫‪© Keren Kalif‬‬
‫המחלקה ‪Animal‬‬
‫שיטות אלו הן ‪final‬‬
‫מאחר ואין סיבה‬
‫לדרוס אותן‬
‫‪49‬‬
‫‪© Keren Kalif‬‬
Horse ‫המחלקה‬
© Keren Kalif
50
Cat ‫המחלקה‬
© Keren Kalif
51
Fish ‫המחלקה‬
© Keren Kalif
52
‫ה‪main -‬‬
‫במקום לבדוק האם החיה היא חתול או סוס‬
‫(וטיפוסים שונים בהמשך)‪ ,‬נבדוק האם‬
‫האובייקט מממש את ההתנהגות המבוקשת‬
‫‪53‬‬
‫‪© Keren Kalif‬‬
‫ירושת ממשקים‬
‫ממשק זה יכלול את כל‬
‫השיטות שבמשק שאותו‬
‫הרחיב ‪ +‬השיטות הנוספות‬
‫הרחבה של יותר ממשק אחד‬
‫קודם תצויין הירושה‬
‫ולאחר מכן הממשקים‬
‫‪54‬‬
‫‪© Keren Kalif‬‬
‫סיכום ביניים לממשקים‬
‫‪ ‬מחלקה יכולה לרשת מאינסוף ממשקים (בניגוד למחלקות‪ ,‬שניתן‬
‫לרשת רק אחת)‬
‫‪ ‬זו תהייה הדרך שלנו לרשת מכמה מחלקות‬
‫‪ ‬ניתן להגדיר אוסף שההפניות שלו הן לאיברים מטיפוס הממשק‪,‬‬
‫כאשר בפועל האובייקטים שונים לחלוטין במהותם‬
‫‪ ‬ניתן להגדיר אוסף פעולות המייצגות התנהגות מסוימת שתמומש‬
‫ע"י מחלקות הרוצות לתמוך בהתנהגות זו‬
‫‪ ‬מאחר וממשק הוא מעין מחלקה אבסטרקטית‪ ,‬לא ניתן להגדיר‬
‫אובייקטים מטיפוס המחלקה‪ ,‬אבל כן ניתן להגדיר הפניות‬
‫‪55‬‬
‫‪© Keren Kalif‬‬
‫השיטה ‪Arrays.sort‬‬
‫‪ ‬השיטה ‪ Arrays.sort‬מקבלת מערך וממיינת את איבריו‬
‫‪ ‬עבור טיפוסים בסיסיים השיטה יודעת לבצע את העבודה מאחר‬
‫והיחס > מוגדר היטב עבור טיפוסים אלו‬
‫‪56‬‬
‫‪© Keren Kalif‬‬
‫השיטה ‪Arrays.sort‬‬
‫עבור מערך אובייקטים‬
‫הקומפיילר לא יודע למיין ‪...Person‬‬
‫‪57‬‬
‫יש תעופה בניסיון המיון כי השיטה ‪sort‬‬
‫מתבססת על מימוש הממשק ‪Comparable‬‬
‫‪© Keren Kalif‬‬
‫כיצד עובדת השיטה ‪?sort‬‬
‫‪ ‬כדי להבין‪ ,‬נממש את ‪ sort‬בעצמנו באמצעות ‪:BubbleSort‬‬
‫‪ ‬הקומפיילר לא יודע מה הפירוש של האופרטור > עבור ‪..Object‬‬
‫‪58‬‬
‫‪© Keren Kalif‬‬
‫השיטה ‪ sort‬מתבססת על הממשק ‪Comparable‬‬
‫‪ ‬מאחר ו‪ sort -‬רוצה שהאיברים למיון ידעו לתת תוצאת יחס בין שני‬
‫איברים (גדול‪/‬קטן‪/‬שווה)‪ ,‬היא מתבססת על כך שהם יממשו את‬
‫ההתנהגות המוגדרת בממשק הקיים ‪ Comparable‬המכיל את‬
‫השיטה ‪:compareTo‬‬
‫‪59‬‬
‫‪© Keren Kalif‬‬
‫הממשק ‪Comparable‬‬
‫‪ ‬זהו ממשק המסופק עם השפה‪ ,‬וכדי לממש אותו צריך לממש את‬
‫השיטה‪:‬‬
‫)‪public int compareTo(object obj‬‬
‫‪ ‬השיטה תחזיר‪:‬‬
‫‪ 0 ‬אם ‪ this‬ו‪ obj -‬זהים‬
‫‪ -1 ‬אם ‪this < obj‬‬
‫‪ 1 ‬אם ‪this > obj‬‬
‫‪ ‬ממשק זה ממומש כבר במחלקה ‪String‬‬
‫‪ ‬נרצה לממש אותו כאשר נרצה לאפשר השוואה בין אובייקטים‬
‫‪ ‬נעדיף להשתמש בממשק קיים זה ולא להגדיר אותו מחדש כדי לספק‬
‫שפה אחידה בין המתכנתים‬
‫‪60‬‬
‫‪© Keren Kalif‬‬
‫התיקון‪ :‬מימוש ‪Comparable‬‬
‫יש לציין את שם המחלקה‪,‬‬
‫אחרת תתבצע השוואה מול‬
‫‪ ,Object‬מה שיצריך ‪casting‬‬
‫השוואה לפי שדה ה‪id -‬‬
‫‪61‬‬
‫‪© Keren Kalif‬‬
)2( Comparable ‫ מימוש‬:‫התיקון‬
© Keren Kalif
62
name -‫השוואה לפי שדה ה‬
© Keren Kalif
63
‫דוגמא נוספת‬
‫למימוש‬
Comparable
© Keren Kalif
64
Comparable -‫דוגמא לשימוש ב‬
© Keren Kalif
65
‫השיטה ‪Array.binarySearch‬‬
‫נשים לב שהחיפוש מתבצע לפי‬
‫הקריטריון הממומש ב‪.compareTo -‬‬
‫כדי לבדוק השוואה עפ"י כל השדות צריך‬
‫ש‪ compareTo -‬תהייה ממומשת היטב!‬
‫שיטה זו מבצעת חיפוש בינארי במערך ממוין‪.‬‬
‫משתמשת בממשק ‪ Comparable‬כדי לחפש את האיבר‪.‬‬
‫‪66‬‬
‫‪© Keren Kalif‬‬
‫תמיכה במיונים לפי קריטריונים שונים‬
‫‪ ‬במידה והמחלקה ‪ Person‬תרצה לתמוך באפשרות השוואה פעם‬
‫אחת לפי ת‪.‬ז‪ .‬ופעם אחרת לפי שם‪ ,‬נצטרך להחזיק אינדיקטור‬
‫שיחליט לפי איזה שדה לבצע את ההשוואה‬
‫‪ ‬מימוש זה מסורבל ואינו אלגנטי‬
‫‪ ‬בשפת ‪ C‬השתמשנו במצביעים לפונקציות‬
‫‪ ‬הפתרון‪ :‬מימוש הממשק ‪Comparator‬‬
‫‪67‬‬
‫‪© Keren Kalif‬‬
‫דוגמא‬
© Keren Kalif
68
‫דוגמא‪:‬‬
‫השימוש‬
‫‪69‬‬
‫‪© Keren Kalif‬‬
‫שיכפול מערך הטרוגני‬
‫‪ ‬בהינתן מערך הטרוגני של בסיס ויורשים‪ ,‬אם נרצה לשכפל את כל‬
‫איברי המערך נצטרך לבדוק מהו טיפוסו של כל איבר ורק אז‬
‫לשכפלו‬
‫‪70‬‬
‫‪© Keren Kalif‬‬
‫שכפול מערך‬
‫עבור כל איבר במערך יש לבדוק את‬
‫טיפוסו ולייצר העתק ע"י מעבר ב‪-‬‬
‫‪ copy c’tor‬של המחלקה המתאימה‬
‫‪71‬‬
‫‪© Keren Kalif‬‬
‫הפלט‬
© Keren Kalif
72
‫היינו שמחים לו ה‪ main -‬נראה כך‪...‬‬
‫כלומר אין צורך לבדוק‬
‫מהו טיפוס האובייקט‬
‫‪73‬‬
‫‪© Keren Kalif‬‬
‫‪Cloneable: Marking Interface‬‬
‫‪ ‬במחלקה ‪ Object‬ישנה המתודה ‪ clone‬אשר יודעת לשכפל את‬
‫נתוני האובייקט‬
‫‪ ‬מתודה זו הינה ‪ private‬ולכן עלינו לדרוס אותה כדי שתהייה‬
‫‪public‬‬
‫‪74‬‬
‫‪© Keren Kalif‬‬
main -‫התוספת ל‬
clone ‫בגלל שהמתודה‬
object ‫מחזירה‬
© Keren Kalif
75
‫על מנת לחסוך את ה‪ casting -‬ב‪main -‬‬
‫בשפת ‪ JAVA‬מותר לשנות את‬
‫הערך המוחזר של מתודה נדרסת‬
‫‪76‬‬
‫‪© Keren Kalif‬‬
‫סיכום‪ :‬השיטה ‪ clone‬והממשק ‪Cloneable‬‬
‫‪ ‬המימוש של ‪ clone‬בשפת ‪ JAVA‬קצת שונה ממה שאנחנו רגילים‪:‬‬
‫‪ ‬יש לממש את הממשק ‪ ,Cloneable‬שהוא למעשה ממשק ללא שיטות‬
‫(‪)marking interface‬‬
‫‪ ‬יש לדרוס את השיטה ‪ clone‬המוגדרת ב‪ Object -‬כ‪ private -‬ולשנות‬
‫את הרשאת השיטה להיות ‪public‬‬
‫‪ ‬מימוש ברירת המחדל של ‪ clone‬הוא לבצע העתקה רדודה של שדות‬
‫האובייקט וכן לבדוק שהקריאה נעשתה תוך מימוש הממשק‬
‫‪ ,Cloneable‬אחרת תזרק חריגה‬
‫‪ ‬חתימת השיטה‪:‬‬
‫‪ ‬השיטה מחזירה ‪ Object‬כי לא יכלו לצפות מה יהיה הערך המוחזר‬
‫‪77‬‬
‫‪© Keren Kalif‬‬
‫דוגמא נוספת‪ :‬המחלקה ‪Point‬‬
‫קריאה למימוש ברירת המחדל מהאב שמממש העתקה רדודה‬
‫של השדות ובודק שאכן מוגדר מימוש לממשק ‪Cloneable‬‬
‫‪78‬‬
‫‪© Keren Kalif‬‬
main -‫שימוש ב‬
© Keren Kalif
79
‫מה קורה אם לא מציינים שמממשים את‬
‫‪?Cloneable‬‬
‫קריאה לשיטה ‪ clone‬ב‪ main -‬תייצר תעופה‪ ,‬בגלל‬
‫שהמימוש של ‪ super.clone‬בודק את השימוש בממשק‬
‫‪80‬‬
‫‪© Keren Kalif‬‬
‫‪ Clone‬והכלה‪ :‬המחלקה ‪Circle‬‬
‫מימוש ברירת המחדל של ‪ Clone‬עושה העתקה רדודה‪,‬‬
‫ובמקרה של שדה שהוא אובייקט תיווצר הפניה כפולה‪.‬‬
‫‪81‬‬
‫‪© Keren Kalif‬‬
main -‫ ה‬:‫ רדוד‬clone -‫דוגמא ל‬
x=4
x=2
y=3
y=2
radius=5
point=
x=4
x=6
y=3
y=7
radius=5
point=
© Keren Kalif
82
‫דוגמא לשכפול עמוק‪:‬‬
‫המחלקה ‪Circle‬‬
‫ב‪ clone -‬דורסים את המימוש המעתיק‬
‫את ההפניות שהתקבל כברירת המחדל‬
‫ב‪ set -‬דואגים שהנקודה תהיה‬
‫יחודית למעגל‪ ,‬ולכן יוצרים העתק‬
‫‪83‬‬
‫‪© Keren Kalif‬‬
main -‫ ה‬:‫ עמוק‬clone -‫דוגמא ל‬
x=4
x=2
y=3
y=2
radius=5
point=
x=4
x=6
y=3
y=7
radius=5
point=
x=4
y=3
© Keren Kalif
84
© Keren Kalif
‫ אוספים‬- Collections
‫אוספים‬
‫‪ ‬אוסף הינו מבנה נתונים המאפשר לנו להחזיק כמות כלשהי של‬
‫איברים בעלי מכנה משותף‬
‫‪ ‬שפת ‪ JAVA‬מספקת לנו מחלקות מובנות המאפשרות לנו‬
‫להשתמש בכל מיני סוגי אוספים‪ ,‬ובפרט המחלקה ‪Vector‬‬
‫שתפקידה לשמש כמערך שאינו מוגבל בגודלו‬
‫‪ ‬במימוש האוספים ע"י ‪ JAVA‬ישנו שימוש במנגנון הנקרא‬
‫‪ generics‬שבו למעשה כותבים את המחלקה פעם אחת‪,‬‬
‫ומעבירים כפרמטר ב‪ > < -‬את הטיפוס של אוסף הנתונים‬
‫‪ ‬הטיפוס חייב להיות שם של מחלקה ולא טיפוס בסיסי‬
‫‪ ‬למשל‪ Integer :‬ולא ‪int‬‬
‫‪ ‬נהוג גם לקרוא לאוסף בשם ‪container‬‬
‫‪86‬‬
‫‪© Keren Kalif‬‬
‫דוגמא לשימוש במחלקה המובנית ‪Vector‬‬
‫טיפוס איברי המערך הוא מחלקה‬
‫‪10‬‬
‫הגודל הפיזי ההתחלתי‬
‫של המערך הוא ‪10‬‬
‫‪0‬‬
‫‪10‬‬
‫‪2‬‬
‫ניתן לראות כי ברגע שהמקום במערך‬
‫נגמר המחלקה מגדילה אותו פי ‪2‬‬
‫‪20‬‬
‫‪11‬‬
‫]‪[5, 2, 3, 4, 1, 7, 2, 9, 0, 4, 7‬‬
‫‪87‬‬
‫‪© Keren Kalif‬‬
‫‪F‬‬
‫‪T‬‬
‫מחלקות העוטפות טיפוסים בסיסיים‬
‫‪ ‬עבור כל אחד מהטיפוסים הבסיסיים ישנה מחלקה שעוטפת אותו‪,‬‬
‫כדי שנוכל להשתמש בה במקרה הצורך‪ ,‬למשל כפרמטר למחלקה‬
‫‪vector‬‬
‫‪ ‬אובייקטים אלו הם מסוג ‪ ,immutable‬כלומר לא ניתן לשנות‬
‫אותם‪.‬‬
‫‪ ‬כל שינוי למעשה מייצר אובייקט חדש (כמו ‪ ,)String‬ולכן העבודה‬
‫איתם יכולה להיות לא כ"כ יעילה‬
‫‪ ‬לכן במקרים בהם נרצה לשנות את איברי הוקטור שאיברים בסיסיים‬
‫באופן תדיר‪ ,‬נעדיף להשתמש דווקא במערך‬
‫‪88‬‬
‫‪© Keren Kalif‬‬
:‫תזכורת‬
Point ‫המחלקה‬
© Keren Kalif
89
‫דוגמא‬
‫קבלת הפניה לאיבר בוקטור‬
‫ושינוי ערכו‪ .‬השינוי משפיע‬
‫על האיבר שבוקטור‪.‬‬
‫קבלת הפניה לאיבר בוקטור‬
‫ושינוי ערכו‪ .‬השינוי אינו‬
‫משפיע על האיבר שבוקטור‪.‬‬
‫‪90‬‬
‫‪© Keren Kalif‬‬
‫האם הוקטור מחזיק את האיברים כהפניות‬
‫או כהעתקים??‬
‫ניתן לראות כי הוקטור מחזיק הפניות לאיברים‪ ,‬ואם‬
‫רוצים העתק יחודי לאובייקט בתוך המערך‪ ,‬יש לשלוח‬
‫באמצעות ‪( new‬מעבר ב‪ )copy c’tor -‬או ‪clone‬‬
‫])‪[(1, 1), (2, 2), (1, 1‬‬
‫])‪[(5, 1), (2, 2), (1, 1‬‬
‫‪91‬‬
‫‪T‬‬
‫ניתן לראות כי השיטה ‪ contains‬בודקת האם‬
‫איבר קיים באמצעות השיטה ‪ equals‬ולא ==‬
‫(בודקת תוכן ולא הפניה)‬
‫‪© Keren Kalif‬‬
‫המחלקה ‪Vector‬‬
‫‪ ‬בלינק הבא ניתן למצוא את התיעוד למחלקה‪:‬‬
‫‪http://java.sun.com/j2se/1.4.2/docs/api/java/util/Vector.html‬‬
‫‪ ‬ניתן לראות כי המחלקה מממשת‪ ,‬בין היתר‪ ,‬את הממשק‬
‫‪Collection‬‬
‫‪92‬‬
‫‪© Keren Kalif‬‬
‫הממשק ‪Collection‬‬
‫‪ ‬ממשק זה מגדיר את כל השיטות שהגיוני שיהיו לאוסף‬
‫‪ ‬ניתן לקרוא על כל אחת מהשיטות בתיעוד של הממשק‪:‬‬
‫‪http://java.sun.com/j2se/1.4.2/docs/api/java/util/Collection.html‬‬
‫‪93‬‬
‫‪© Keren Kalif‬‬
‫המחלקה ‪Iterator‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫על איבריו של ‪ Vector‬ניתן לעבור בלולאה רגילה כמו שעוברים על‬
‫מערך‬
‫ישנם אוספים אשר לא מאפשרים מעבר באמצעות ] [ אלא‬
‫באמצעות אובייקט הנקרא איטרטור )‪ (Iterator‬שהוא למעשה‬
‫הפניה לאיבר כלשהו באוסף‬
‫לכל אוסף יש את השיטה )(‪ iterator‬המחזירה איטרטור לאיבר‬
‫הראשון באוסף‬
‫לאובייקט מטיפוס איטרטור יש ‪ 2‬שיטות המאפשרות לעבור על כל‬
‫איברי האוסף‪:‬‬
‫‪ hasNext ‬המחזירה ‪ true‬במידה ויש איברים נוספים‬
‫‪ next ‬המחזירה את ערך האיבר הבא‬
‫‪94‬‬
‫‪© Keren Kalif‬‬
‫דוגמאת שימוש ב‪-‬‬
‫‪Iterator‬‬
‫קבלת איטרטור לאיבר‬
‫הראשון באוסף‬
‫כל עוד יש איברים באוסף‬
‫קבלת האיבר הבא‬
‫‪95‬‬
‫‪© Keren Kalif‬‬
‫הגדרת‬
‫איטרטור‬
‫מטיפוס‬
‫איברי‬
‫האוסף‬
‫מבנה הנתונים ‪Set‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪96‬‬
‫‪( Set‬קבוצה) הינו אוסף שמכיל כל ערך פעם אחת בלבד‪ ,‬כלומר‬
‫לא יתכנו כפילויות של הערכים‬
‫ניסיון הוספה של ערך שכבר קיים לא יבוצע‬
‫‪ Set‬הינו ממשק לכל המחלקות הרוצות לממש מבנה נתונים זה‬
‫ההבדל בין המחלקות השונות הממשות מבנה נתונים זה הוא‬
‫הדרך בה הן מחזיקות את המידע (רשימה מקושרת‪ ,‬עץ וכד')‬
‫‪© Keren Kalif‬‬
‫דוגמאת שימוש ב‪set -‬‬
‫השיטה ‪ add‬מחזירה ‪ true‬במידה‬
‫והערך הוכנס לאוסף‪ false ,‬אחרת‬
‫‪ LinkedHashSet‬הינה מחלקה המממשת את הממשק‬
‫‪ set‬והיא שומרת את האיברים לפי סדר הכנסתם‬
‫‪ TreeSet‬הינה מחלקה המממשת את הממשק‬
‫‪ set‬והיא שומרת את האיברים ממוינים‬
‫‪97‬‬
‫‪© Keren Kalif‬‬
‫‪ Set‬שאיבריו הם אובייקט‬
‫ניתן לראות כי איבר נכנס לאוסף רק אם‬
‫עדיין אין הפניה אליו (כלומר בדיקה האם‬
‫איבר קיים הינה באמצעות == ולא ‪(equals‬‬
‫‪98‬‬
‫‪© Keren Kalif‬‬
‫‪ Set‬של אובייקטים ללא כפילויות בערכים‬
‫‪ ‬כל אובייקט מקבל בירושה מ‪ Object -‬את המתודה ‪hashCode‬‬
‫‪ ‬ניתן לדרוס אותה על‪-‬מנת לקבל ‪ int‬המזהה את האובייקט באופן חד‪-‬‬
‫חד ערכי‬
‫‪ ‬כל שני אובייקטים שערכיהם שווים יהיו בעלי ערך ‪ hashCode‬זהה‬
‫‪ ‬יתכן ו‪ 2 -‬אובייקטים עם ערכים זהים יקבלו ערך ‪ hashCode‬זהה‬
‫‪ ‬שימושי כאשר האובייקט נמצא בתוך אוסף שיש לזהות את‬
‫האובייקטים עפ"י ערכם‪ ,‬ולא בהכרח עפ"י הפנייתם‬
‫‪ ‬כאשר מחלקה מממשת את המתודה ‪ hasCode‬האוסף ‪ Set‬בודק‬
‫כפילויות באמצעות ‪ hasCode‬ולא באמצעות ==‪ ,‬כך שלא יתכנו ‪2‬‬
‫אובייקטים עם ערכים זהים‬
‫‪99‬‬
‫‪© Keren Kalif‬‬
‫דוגמא‬
© Keren Kalif
100
‫תמיכה במיונים לפי קריטריונים שונים‬
‫‪ ‬במידה ונרצה להחזיק אוסף ממויין‪ ,‬מבלי לייצר הצמדה בין הטיפוס‬
‫לאופן ההשוואה‪ ,‬משתמש ב‪Comparator -‬‬
‫‪ ‬בשפת ‪ C‬השתמשנו במצביעים לפונקציות‬
‫‪101‬‬
‫‪© Keren Kalif‬‬
‫דוגמא‬
© Keren Kalif
102
‫דוגמא‪:‬‬
‫השימוש‬
‫‪103‬‬
‫‪© Keren Kalif‬‬
‫מבנה הנתונים ‪Map‬‬
‫‪ map ‬הינו אוסף המאפשר פניה לערך מסויים באמצעות מפתח‬
‫כלשהו‪ ,‬ולא בהכרח באמצעות אינדקס מספרי‬
‫‪ ‬ניתן גם להסתכל עליו כעל מערך‪ ,‬שהאינדקסים שלו אינם בהכרח‬
‫מטיפוס ‪int‬‬
‫‪ ‬נשתמש בו כאשר נרצה למפות ערכים ממפתח מסוים‪ ,‬לערך‬
‫אחר‬
‫‪ ‬כל מפתח יכול להופיע פעם בלבד‬
‫‪ ‬ניסיון הוספה למפתח קיים ידרוס את ערכו הקוד‬
‫‪ map ‬הינו ממשק לכל המחלקות הרוצות לממש מבנה נתונים‬
‫זה‬
‫‪104‬‬
‫‪© Keren Kalif‬‬
‫דוגמא ‪1‬‬
‫‪26/11/1978‬‬
‫‪Daphna‬‬
‫‪21/2/1974‬‬
‫‪Guy‬‬
‫‪30/4/1980‬‬
‫‪Jasmine‬‬
‫‪Value‬‬
‫‪ Map‬שהמפתח הוא‬
‫מחרוזת והערך תאריך‬
‫הוספת ערכים‬
‫באמצעות השיטה‬
‫‪ put‬המקבלת‬
‫מפתח וערך‬
‫מעבר על כל איברי המפה‬
‫‪105‬‬
‫‪© Keren Kalif‬‬
‫‪Key‬‬
‫שימו לב‪ Date :‬היא‬
‫מחלקה שאני כתבתי‪ ,‬ולא‬
‫המחלקה שב‪java.utils -‬‬
‫דוגמא ‪2‬‬
‫‪ get‬מקבלת ערך של מפתח‬
‫מסויים ומחזירה הפניה ל‪value -‬‬
‫אם קיים‪ ,‬אחרת מחזירה ‪null‬‬
‫שינוי ערך ההפניה‬
‫שקיבלנו משפיע‬
‫על ערכו ב‪map -‬‬
‫‪106‬‬
‫‪© Keren Kalif‬‬
‫דוגמא ‪3‬‬
‫בדיקה האם מפתח‬
‫מסויים קיים‬
‫בדיקה האם ערך‬
‫מסויים קיים (בדיקה‬
‫באמצעות ‪)equals‬‬
‫‪107‬‬
‫‪© Keren Kalif‬‬
‫דוגמא ‪4‬‬
‫הוספת ערך למפתח‬
‫קיים תדרוס את‬
‫הערך הקודם‬
‫גם פה בדיקת המפתח היא באמצעות‬
‫==‪ ,‬ואם רוצים שתבוצע באמצעות‬
‫‪ equals‬יש לדרוס את ‪hashCode‬‬
‫‪108‬‬
‫‪© Keren Kalif‬‬
‫‪MultiMap‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪109‬‬
‫הינה מחלקה המממשת את המממשק ‪ map‬אך מאפשרת יותר‬
‫מערך אחד לכל מפתח‬
‫קבלת ערכי מפתח מסויים תחזיר משתנה מהטיפוס ‪Collection‬‬
‫מחלקה זו אינה נמצאת בספריה הסטנדרטית של ‪ java.utils‬אלא‬
‫בתת‪-‬ספריה של ‪ org.apache‬שצריך לייבא לתוך הפרוייקט‬
‫חלופה ל‪ MultiMap -‬הינה ‪ map‬שה‪ value -‬שלו מטיפוס ‪Vector‬‬
‫‪© Keren Kalif‬‬
‫מימוש ספר‬
‫טלפונים (‪)1‬‬
‫‪110‬‬
‫‪© Keren Kalif‬‬
‫הנתונים הם בתוך מפה שהערך שלה הוא מערך‬
‘A’
‘A’
“assaf”, “amir"
‘B’
‘B’
“beni”
…
…
‘Z’
‘Z’
Key
“ziv”, “zodiak”
Value
© Keren Kalif
111
© Keren Kalif
112
main -‫ה‬
© Keren Kalif
113
Collections ‫המחלקה‬
‫ מחלקה זו מכילה אוסף שיטות סטטיות לעבודה עם אוספים‬
:‫ ניתן לקרוא על כל אחד מהשיטות בתיעוד המחלקה‬
http://java.sun.com/j2se/1.4.2/docs/api/java/util/Collections.html
:‫ השיטות הנפוצות‬
max, min, replaceAll, frequency, reverse, rotate, shuffle, sort 
© Keren Kalif
114
‫דוגמאות‬
Collections -‫לשימוש ב‬
© Keren Kalif
115
Collections ‫שימוש בממשקים במחלקה‬
‫ בטיפוס‬Comparable ‫ מניחה מימוש של הממשק‬Sort ‫ השיטה‬
‫איברי האוסף‬
‫ אם טיפוס איברי האוסף לא מימש ממשק זה תהיה שגיאה‬
‫קומפילציה‬
Bound mismatch: The generic method sort(List<T>) of type
Collections is not applicable for the arguments (LinkedList<Point>).
The inferred type Point is not a valid substitute for the bounded
parameter <T extends Comparable<? super T>>
© Keren Kalif
116
© Keren Kalif
static constructor
‫‪© Keren Kalif‬‬
‫‪static constructor‬‬
‫‪ ‬כאשר יש מחלקה עם תכונות סטטיות הן נוצרות לפני יצירת‬
‫האובייקט‪ ,‬וניתן לאתחלן בשורת ההגדרה של התכונה‬
‫‪ ‬יתכן ונרצה לאתחל תכונה מורכבת‪ ,‬למשל ‪ map‬ולא ניתן לעשות‬
‫זאת בשורת ההגדרה של האובייקט‬
‫‪ ‬כדי לאתחל שדה סטטי מורכב‪ ,‬למשל ‪ ,map‬היינו כותבים שיטה‬
‫סטטית לאתחול התכונה‬
‫‪ ‬החיסרון‪ :‬המשתמש במחלקה צריך להפעיל שיטה זו באופן יזום‬
‫‪ ‬הפתרון‪ static c’tor :‬המופעל באופן אוטומטי עם תחילת התוכנית‬
‫‪118‬‬
‫איתחול תכונה עם הגדרתה‬
‫‪static c’tor‬‬
‫ה‪ static c’tor -‬מופעל לפני‬
‫השימוש הראשון במחלקה‬
120
© Keren Kalif
:‫ביחידה זו למדנו‬
JoptionPane
String ‫המחלקה‬
Date ‫המחלקה‬
‫מחלקה פנימית‬
Object ‫המחלקה‬
‫ממשקים‬
‫אוספים‬
static c’tor







