2007 Zindell Technologies, Ltd.

Transcription

1 1 הורשה )Inheritance( הקדמה Derivation Syntax אופן הגדרתה של מחלקה שיורשת מאחרת - משמעות ההורשה - Effects Inheritance הרשאות הגישה Modifiers Access הגדרתן מחדש של מתודות שהגיעו בהורשה - Methods Overriding מחלקות אבסטרקטיות - Classes Abstract ממשק Interface שינוי טיפוס של Casting הפיכת ערך מטיפוס בסיסי לאובייקט ולהפך - Versa Converting Primitive Types to Objects & Vice מתודות שתם זמנן Deprecation מחלקות מוכנות ליצירת מבני נתונים

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

3 3 המשאיות. את ההיררכיה שזיהינו נוכל גם לתאר בתרשים הבא: המחלקה הכללית יותר תיקרא בשם מחלקת האב, ובאנגלית באחד השמות הבאים: )super class( base class המחלקה הספציפית יותר תיקרא בשם מחלקת הבן, ובאנגלית באחד השמות הבאים: )sub class( derived class

4 4 את ההגדרה של המאפיינים המשותפים למחלקת האב ולמחלקת הבן נוכל למצוא במחלקת האב. במחלקת הבן, אנו נוסיף להגדרה שמגיעה בהורשה מאפיינים נוספים. המחלקה )מחלקת הבן( שיורשת ממחלקה אחרת )ממחלקת האב( מקבלת ממנה את כל התכונות והפעולות שמוגדרות בה, כלומר, מקבלת את כל המשתנים ואת כל המתודות שהוגדרו בה. משמעות הדבר היא שבמחלקת הבן יתקיימו, באופן אוטומאטי, כל המשתנים וכל המתודות שהוגדרו עוד במחלקת האב, וזאת מבלי שיהיה צריך להגדירן מחדש. במחלקת הבן נוסיף תכונות ופעולות נוספות )מתודות ומשתנים נוספים( בכך שנגדיר אותן בתוך הגדרתה. אם נרצה, נוכל גם להגדיר מחדש במחלקת הבן מתודות שהגיעו בהורשה ממחלקת האב, ובכך לשנות את מה שהגיע בירושה בהורשה. השימוש באפשרות לייצור מחלקה שיורשת )שנגזרת( מאחרת חוסך הרבה כתיבה של קוד מקור הן ביצירתה של המחלקה והן בשינויים שרוצים לעשות לאחר מכן באופן פעולתה, ובייחוד אם אותם שינויים אמורים גם לגביה וגם לגבי מחלקות אחרות אשר נמצאות בהיררכיה. אופן הגדרתה של מחלקה שיורשת מאחרת - Syntax Derivatin הגדרתה של מחלקה שיורשת ממחלקה אחרת נקרא גם בשם.extending האופן שבו מגדירים מחלקה שיורשת ממחלקה אחרת הוא כדלקמן: בהמשך שורת הכותרת של המחלקה שמגדירים יש לרשום את המילה extends ומייד אחריה את שמה של המחלקה המורישה. לאחר מכן, בתוך הסוגרים המסולסלות של המחלקה המוגדרת ניתן להוסיף משתנים ומתודות אשר יתווספו לאלה שהגיעו בהורשה. לדוגמא :

5 5 public class Car int size, color, speed; public void park)(... public class PrivateCar extends Car int doors;... בדוגמא זו, המחלקה PrivateCar יורשת מהמחלקה,Car משמע, כל שלושת המשתנים שהוגדרו במחלקה Car )המשתנים size, color ו- )speed ולפיכך קיימים בכל אחד מהאובייקטים ששייכים למחלקה Car יהיו קיימים גם בכל אחד מהאובייקטים ששייכים למחלקה.PrivateCar כמו כן, המתודה park שהוגדרה במחלקה Car ניתן יהיה להפעיל אותה גם על כל אחד מהאובייקטים ששייכים למחלקה.PrivateCar בכל אחד מהאובייקטים ששייכים למחלקה PrivateCar יהיו, בנוסף, גם המשתנים הנוספים )כדוגמת )doors וגם המתודות הנוספות אשר הוגדרו במחלקה.Car לאחר שהיא ירשה מהמחלקה PrivateCar

6 6 ב- JAVA )להבדיל מ- C++( כל מחלקה יכולה לרשת רק ממחלקה אחת. ב- JAVA אין הורשה מרובה )מצב שבו מחלקה נתונה יורשת ממספר מחלקות(. תכנון התכנית תחת המגבלה שלא ניתן לרשת מיותר ממחלקה אחת יותר מבני ויותר מסודר. כאשר תכנון המחלקות נכון ומסודר, אין צורך בהורשה מרובה. עם זאת, אין כל מגבלה על מחלקה מלהוריש ליותר ממחלקה אחת. מחלקה יכולה להוריש למספר בלתי מוגבל של מחלקות. כל מחלקה שמגדירים ולא מציינים שהיא יורשת ממחלקה אחרת תירש )כברירת מחדל( מהמחלקה Object את כל תכונותיה)המשתנים( ואת כל המתודות שמוגדרות בה. אם המחלקה שהגדרנו יורשת ממחלקה אחרת אז התכונות והמתודות שהוגדרו במחלקה Object יגיעו בהורשה מאותה מחלקה אחרת. אם גם המחלקה האחרת ירשה ממחלקה אז בדיקה של היררכית המחלקות תגלה מהר מאד כי במעלה ההיררכיה מגיעים לבסוף למחלקה שלא יורשת מאף אחת. מחלקה זו היא שתירש את התכונות ואת המתודות שהוגדרו במחלקה Object ותעבירן הלאה במורד ההיררכיה עד למחלקה שבוחנים. מסיבה זו, ניתן לומר, כי התכונות שהוגדרו במחלקה Object קיימות בכל אובייקט... מכל סוג. כמו כן, ניתן גם לומר כי המתודות שהוגדרו במחלקה Object ניתן להפעילן על כל אובייקט. התכנית הבאה מתארת הורשה פשוטה בין שתי מחלקות. class Person protected String name; protected int age; public Person)(

7 public Person)String nameofperson, int ageofperson( 7 name = nameofperson; age = ageofperson; public void showdetails)( System.out.println)"name : " + name + "\nage : " + age(; class Jewish extends Person protected boolean britmila; // false if wasn't done true if was done protected boolean israeli; // false if not israeli true if israeli public Jewish)String nameofperson, int ageofperson, boolean brit, boolean israeliyesno(

8 8 name = nameofperson; age = ageofperson; britmila = brit; israeli = israeliyesno; class Christian extends Person protected boolean catolic; // false if not true if yes public Christian)String nameofperson, int ageofperson, boolean catol( name = nameofperson; age = ageofperson; catolic = catol;

9 9 class Muslim extends Person protected boolean israeli; // false if not true if yes public Muslim)String nameofperson, int ageofperson, boolean fana( name = nameofperson; age = ageofperson; israeli = fana; class SimpleInheritanceDemo public static void main)string args[]( Muslim palestiny = new Muslim)"Muhamad", 20, false(; Christian canadian = new Christian)"Jhon", 22, true(;

10 10 Jewish zabar = new Jewish)"David", 24, true, true(; palestiny.showdetails)(; canadian.showdetails)(; zabar.showdetails)(; משמעות ההורשה - Inheritance Effects of כאשר מחלקה יורשת ממחלקה אחרת אז כל משתנה שהוגדר במחלקה האחרת יהיה קיים בכל אחד מהאובייקטים שנוצרים מהמחלקה היורשת. באופן דומה, כל מתודה שהוגדרה במחלקה האחרת ניתן יהיה להפעיל אותה על כל אובייקט שנוצר מהמחלקה היורשת. להבדיל מ-++ C, ב- Java אין סוגים שונים של הורשה. ב- Java יש הורשה מסוג אחד, ובמסגרתה כל המשתנים וכל המתודות עוברים בהורשה. עם זאת, בהחלט ייתכן מצב שעקב הרשאת הגישה של המשתנה/מתודה שעברו בהורשה הפניה למשתנה ו/או הקריאה להפעלת המתודה לא יתאפשרו באופן ישיר. כך לדוגמא, משתנה שהוגדר עם הרשאת הגישה private במחלקה המורישה, יהיה קיים בתוך כל אובייקט אשר יווצר מהמחלקה היורשת. עם זאת, הגישה הישירה אליו לא תתאפשר מתוך גבולות המחלקה היורשת. הגישה היחידה שתתאפשר אליו היא באופן עקיף באמצעות קריאה להפעלתה של מתודה שהוגדרה במחלקה היורשת ושבגבולותיה אין כל בעיה למקם פניה למשתנה האמור. כל אובייקט שנוצר מהמחלקה היורשת מכיל לפיכך את כל המשתנים שהוגדרו במחלקה המורישה ואת כל המשתנים שהוגדרו במחלקה היורשת. על כל אחד מהאובייקטים שיווצרו מהמחלקה היורשת ניתן יהיה להפעיל את כל אחת מהמתודות שהוגדרו במחלקה המורישה וגם את כל אחת מהמתודות שהוגדרו במחלקה היורשת.

11 11 את ה- reference לאובייקט מטיפוס מחלקה נתונה ניתן לאחסן במשתנה מטיפוס המחלקה הנתונה )זאת כבר וודאי ידוע(, אך ניתן גם לאחסן אותו במשתנה מטיפוס מחלקה שהורישה למחלקה הנדונה )בין אם הורישה באופן ישיר ובין אם הורישה באופן עקיף דרך מחלקה אחרת(. לדוגמא )המשך הדוגמא מעמוד 4(: Car mycar = new PrivateCar)(; הסיבה לכך שזה אפשרי )ההיפך לא אפשרי: לא ניתן לאחסן reference לאובייקט מטיפוס Car בתוך משתנה מטיפוס )PrivateCar היא שכל המשתנים שנצפה שיהיו באובייקט מטיפוס Car קיימים גם באובייקט מטיפוס PrivateCar )הוא יורש מ- Car ( ובאופן דומה, כל המתודות שהוגדרו במחלקה Car ניתן להפעילן גם על כל אובייקט מטיפוס.Private Car התכנית הבאה מדגימה את שנאמר: class Person public String name; public int age; public Person)( public Person)String nameofperson, int ageofperson(

12 12 name = nameofperson; age = ageofperson; public void showdetails)( System.out.println)"name : " + name + "\nage : " + age(; class Jewish extends Person boolean britmila; // false if wasn't done true if was done boolean israeli; // false if not israeli true if israeli public Jewish)String nameofperson, int ageofperson,

13 13 boolean brit, boolean israeliyesno( name = nameofperson; age = ageofperson; britmila = brit; israeli = israeliyesno; class Christian extends Person boolean catolic; // false if not true if yes public Christian)String nameofperson, int ageofperson, boolean catol( name = nameofperson; age = ageofperson; catolic = catol;

14 14 class Muslim extends Person boolean israeli; // false if not true if yes public Muslim)String nameofperson, int ageofperson, boolean fana( name = nameofperson; age = ageofperson; israeli = fana; class DerivedToBase public static void main)string args[](

15 15 Person palestiny = new Muslim)"Muhamad", 20, false(; Person canadian = new Christian)"Jhon", 22, true(; Person zabar = new Jewish)"David", 24, true, true(; palestiny.showdetails)(; canadian.showdetails)(; zabar.showdetails)(; הרשאות הגישה הקדמה כפי שכבר הוסבר בפרק מספר 3, ניתן להוסיף בתחילת שורת ההצהרה על משתנה/מתודה את אחת המלים הבאות: private public protected בהוספת כל אחת מהמלים הנ"ל יש השפעה על אפשרות הגישה/השימוש במשתנה/מתודה. למרות שנושא זה כבר הוסבר )למעט,)protected בחרתי לחזור ולהסבירו שוב, והפעם גם להתייחס להרשאת הגישה.protected

16 16 הרשאת הגישה private משתנה/מתודה שמוסיפים להם את הרשאת הגישה private בשורת ההצהרה שלהם ניתן יהיה לגשת/להפעיל אליהם/אותם אך ורק כשזה נעשה בגבולות של מתודות ששייכות למחלקה שבה הוצהר על אותו משתנים/מתודה. הרשאת הגישה public משתנה/מתודה שמוסיפים להם את הרשאת הגישה public בשורת ההצהרה שלהם ניתן יהיה לגשת/להפעיל אליהם/אותם בכל מקום. הרשאת הגישה protected משתנה/מתודה שמוסיפים להם את הרשאת הגישה protected בשורת ההצהרה שלהם ניתן יהיה לגשת/להפעיל אליהם/אותם אך ורק כאשר נמצאים בגבולות של מתודות ששייכות למחלקה שבה הוצהר על אותם משתנים/מתודות או בתוך מחלקה ששייכת ל- package שאליו שייכת המחלקה שבה הוצהר על אותם משתנים/מתודות או בתוך מתודות ששייכות למחלקה שיורשת ממנה )באופן ישיר או עקיף(. אי מתן הרשאת גישה friendly( )package משתנה/מתודה שלא מוסיפים להם הרשאת גישה בשורת ההצהרה שלהם ניתן יהיה לגשת/להפעיל אליהם/אותם אך ורק בתוך מתודות ששייכות למחלקה שבה הוצהר על אותם משתנים/מתודות או בתוך מתודות ששייכות למחלקות אחרות ששייכות לאותו package שאליו שייכת המחלקה. כדי להבין את שהוסבר בנוגע לכל אחת מהרשאות הגישה האפשריות, ניעזר בדוגמא הבאה. הנח כי במחלקה package שייכת ל-: DramaBook מוגדרים מספר רכיבים עם הרשאות גישה שונות. הנח גם שהמחלקה DramaBook books וכי יחד עמה שייכות ל- package הזה גם המחלקות הבאות:.ComedyBook, SportBook הנח, בנוסף, את

17 17 קיומו של package אחר בשם: movies אשר כולל בתוכו את המחלקות: DramaMovie ו-.ArabicMovie הנח גם כי המחלקה DramaMovie יורשת מהמחלקה,DramaBook וכי המחלקה SportBook יורשת מהמחלקה.DramaBook בתרשים הבא, ניתן לראות ייצוג גראפי לתיאור קשרים אלה. כעת, נסכם את שמות המחלקות שמתוכן ניתן לגשת לכל אחד מרכיבי המחלקה DramaBook אשר כל אחד מהם קיבל הרשאת גישה שונה. הרשאת הגישה public protected package-friendly private שמות המחלקות שממתודות שמוגדרות בהן ניתן לגשת אל הרכיב ComedyBook, SportBook, DramaBook, DramaMovie, ArabicMovie ComedyBook, SportBook, DramaBook, DramaMovie ComedyBook, SportBook, DramaBook DramaBook

18 18 הגדרתן של מתודות שהגיעו בהורשה מחדש - Methods Overriding הקדמה כאשר מגדירים במחלקה היורשת מתודה שזהה בשמה, בטיפוס הערך המוחזר, במספר הפרמטרים שלה ובטיפוס של כל אחד מהם למתודה שהועברה בהורשה ממחלקה אחרת, אז המתודה החדשה תתפוס את מקומה של המתודה שהגיעה בהורשה, ולמצב זה נקרא בשם:.Overriding the method המתודה בגרסתה החדשה באה במקומה של המתודה שהועברה בהורשה, וכך כאשר על אובייקט, שיווצר מהמחלקה שמגדירים, תופעל מתודה זו, המתודה שתפעל היא המתודה החדשה שהוגדרה. כאשר יש קריאה להפעלת מתודה שיש לה מספר גרסאות שונות )מספר גרסאות שונות שנוצרו באמצעות,)overiding הגרסה שתפעל היא הגרסה המתאימה ביותר לטיפוס של האובייקט, ללא כל קשר לטיפוס של ה- reference... כלומר, ללא כל קשר לטיפוס של המשתנה אשר מחזיק ב- reference לאותו אובייקט שעליו מנסים להפעיל את המתודה. יש לשים לב לכך שאם מספר/סוג הפרמטרים במתודה החדשה שמגדירים מעט שונה מזה שבמתודה שהועברה בהורשה אז זו כבר תהיה מתודה אחרת, ולא יהיה פה מצב של.overriding המתודה החדשה שמגדירים כדי שתתפוס את מקומה של מתודה אחרת שהגיעה בהורשה יכולה לזרוק את אותם Exceptions שהמתודה המקורית יכולה לזרוק או רק חלק מהם או Exceptions מסוג שיורש מהסוג שהמתודה המקורית זורקת. לא ניתן לקבוע כי מתודה שתופסת את מקומה של מתודה אחרת תזרוק Exceptions אשר המתודה המקורית לא זרקה. כל האמור לעיל תקף ל- Exceptions מהסוג השלישי... מהסוג שחייבים לטפל בו. אם נושא הטיפול ב- Exceptions ב- JAVA עדיין לא מוכר לך )וסביר שכך( אז אל דאגה. בהמשך הספר מובא פרק שלם שמטפל בנושא ה-,Exceptions ונקודה זו תוסבר בו שוב. הרשאת הגישה של המתודה החדשה, אשר באה לתפוס את מקומה של מתודה אחרת אשר הועברה בהורשה, יכולה להיות זהה לזו של המתודה המקורית או מרחיבה )משמע, מרחיבה את אפשרויות הגישה אליה(. לדוגמא: מתודה

19 19 שהוגדרה במחלקת האב עם הרשאת הגישה protected למתודה שתתפוס את מקומה במחלקה היורשת (.private אך לא ניתן לתת לה את הרשאת הגישה public או protected ניתן לתת את הרשאת הגישה )overriding הסיבה לכך היא כדי שלא יקרה מצב שבזמן ריצה הגירסה של המתודה שתצטרך לפעול לא תוכל לפעול מסיבות של הרשאת גישה. התכנית הבאה מדגימה את האפשרות לעשות overriding למתודות שמגיעות בהורשה ממחלקה אחרת. class Person protected String name; protected int age; public Person)( public Person)String nameofperson, int ageofperson( name = nameofperson; age = ageofperson; public void showdetails)( System.out.println)"name : " + name + "\nage : " + age(;

20 20 class Jewish extends Person protected boolean britmila; // false if wasn't done true if was done protected boolean israeli; // false if not israeli true if israeli public Jewish)String nameofperson, int ageofperson, boolean brit, boolean israeliyesno( name = nameofperson; age = ageofperson; britmila = brit; israeli = israeliyesno; public void showdetails)(

21 21 System.out.println)"name : " + name + "\nage : " + age + "\nbritmila : " + britmila + "\nisraeli : " + israeli(; class Christian extends Person protected boolean catolic; // false if not true if yes public Christian)String nameofperson, int ageofperson, boolean catol( name = nameofperson; age = ageofperson; catolic = catol; class Muslim extends Person

22 22 protected boolean israeli; // false if not true if yes public Muslim)String nameofperson, int ageofperson, boolean fana( name = nameofperson; age = ageofperson; israeli = fana; class SimpleInheritanceDemo public static void main)string args[]( Muslim palestiny = new Muslim)"Muhamad", 20, false(; Christian canadian = new Christian)"Jhon", 22, true(; Jewish zabar = new Jewish)"David", 24, true, true(; palestiny.showdetails)(;

23 23 canadian.showdetails)(; zabar.showdetails)(; בתכנית הנ"ל ניתן לראות כיצד מתודות מוגדרות מחדש overriding( (, וכיצד מופעלת המתודה המתאימה מכל אובייקט ואובייקט. כמו כן, כדאי לשים להערות שבגוף התכנית אשר מדגישות נקודות אחרות שהוזכרו בפרק. באמצעות overriding ניתן, למעשה, לכתוב במחלקות היורשות מתודות שמותאמות יותר למחלקות החדשות שיורשות מה- base-class, ואז, כאשר מאחסנים references לאובייקטים ששייכים למחלקות היורשות בתוך משתנים מטיפוס המחלקות המורישות )אם אינך זוכר שזה אפשרי כדאי שתחזור/תחזרי לקרוא פרק זה מתחילתו(, וקוראים מתוכם להפעלתה של מתודה )חייבת להיות מוגדרת במחלקה המורישה( והמתודה הוגדרה מחדש במחלקתו של האובייקט, במקרים אלה תפעל המתודה האמיתית של האובייקט )המתודה שהוגדרה במחלקה היורשת(. אם את/ה מכיר את שפת התכנות C++ אז אופן פעולה זה וודאי מוכר לך. ב- C++ רואים למתודות שפועלות באופן זה: מתודות )פונקציות( וירטואליות. ב- JAVA כל המתודות וירטואליות )כברירת מחדל(! פעולות הקישור שנעשות בזמן ריצה - Dispatching Dynamic Method כאשר בזמן ריצה של תכנית מופעלת מתודה על אובייקט שה- reference שלו מאוחסן במשתנה מסוים, המתודה המופעלת היא המתודה שהוגדרה במחלקה שאליה אותו אובייקט שייך, וזאת גם אם ה- reference של האובייקט מאוחסן במשתנה מטיפוס מחלקת הבסיס)מחלקת האב, המחלקה המורישה(. קישור זה לשם הפעלת המתודה המתאימה נעשה בזמן ריצה, ובדרך זו מנוצלת האפשרות לביצוע overriding ביעילות. לדוגמא: Person p = new Student)(;

24 24 p.getname)(; בהנחה שהמחלקה Student יורשת מהמחלקה,Person ובהנחה שבשתי המחלקות הוגדרה המתודה,getName אז המתודה getname שתופעל היא זו שהוגדרה במחלקה,Student למרות שה- reference לאובייקט ה- Student מאוחסן במשתנה מטיפוס המחלקה.Person פולימורפיזם - Polymorphism פולימורפיזם polymorpism )בעברית: רב צורתי( היא היכולת לכתוב שורת/שורות קוד כך שבכל פעם שהיא/הן מופעלת/ות הפקודות שבפועל מתבצעות הן פקודות אחרות. להלן תיאור אחת הדוגמאות השכיחות לפולימורפיזם: כפי שכבר נוכחת לדעת, ניתן לכתוב תכנית שיש בה אובייקטים שונים מטיפוס מחלקות שונות אשר כולן יורשות ממחלקה מסוימת, ובכל אחת מהן מתודה מסוימת, שהגיעה בירושה מאותה מחלקה, מוגדרת מחדש.)overriding( את ה- references לאובייקטים אלה, כפי שגם בזאת נוכחת לדעת, ניתן לאחסן במשתנים מטיפוס אותה מחלקה שהורישה לכל המחלקות שמהן נוצרו האובייקטים. הפעלת המתודה האמורה על כל אחד מהאובייקטים יכולה להיכתב באופן די דומה: באמצעות המשתנה שמכיל reference לאובייקט תיכתב קריאה להפעלת המתודה. כיוון שה- reference לאובייקט יכול להיות מאוחסן במשתנה מטיפוס המחלקה המורישה ניתן למשל, לכתוב לולאה אשר תפעיל את אותה מתודה על כל אחד מהאובייקטים שה- references אליהם מאוחסנים במערך של references מטיפוס המחלקה המורישה. שורת הקוד להפעלת המתודה תחזור על עצמה שוב ושוב בכל איטרציה נוספת של הלולאה, ובכל פעם תופעל מתודה אחרת )בכל פעם תופעל המתודה המתאימה בהתאם לטיפוסו האמיתי של האובייקט(. לדוגמא: Person peoples[] = new Teacher)(, new Student)(, new Manager)(; int totalsalary=0;

25 25 for )int index=0; index<peoples.length; index++( totalsalary = totalsalary + peoples[index].getsalary)(; הקריאה להפעלת המתודה על כל אחד מהאובייקטים זהה מבחינת ה- syntax אך בכל פעם מופעלת מתודה אחרת. על כל אובייקט מופעלת המתודה אשר הוגדרה במחלקה שלו. ה- method הספציפי שיופעל ייקבע בזמן הריצה בהתאם לסוג האובייקט עצמו )ולא בהתאם לטיפוס המשתנה שמכיל את ה- reference אליו(. ניתן גם לפתח מחלקות חדשות שיירשו ממחלקות אלה, וקוד הגישה להפעלת מתודה זו על כל אחד מהאובייקטים שיווצרו ממחלקות אלה עדיין יהיה זהה. פיתוחן של מחלקות חדשות ושילוב האובייקטים שנוצרים על פיהן קל יותר הודות לקיומו של הפולימורפיזם. המילה השמורה super באמצעות מילה שמורה זו ניתן )במהלך פעולתה של מתודה שהוגדרה מחדש במחלקה )overriding להפעיל את המתודה בגרסתה במחלקה שמעל )במחלקה שהורישה למחלקה הנתונה(. אופן השימוש במילה שמורה זו הוא כדלקמן: יש לרשום אותה, ומייד אחריה למקם נקודה מפרידה, ואחריה למקם קריאה להפעלת המתודה. דוגמא: public class SportCar extends Car public int speed)( int result = super.speed)(;

26 26... return result; בדוגמא זו, תוך כדי פעולתה של המתודה speed אשר מוגדרת במחלקה sportcar הופעלה המתודה speed כפי שהיא הוגדרה במחלקה,Car אשר הורישה למחלקה.SportCar יש לשים לב לכך, שלא ניתן להפעיל את המילה השמורה super פעמיים, כלומר, לא ניתן, למשל, לכתוב: super.super.speed)(; בתכנית הבאה מודגם השימוש במילה השמורה.super class Person public String name; public int age; public Person)(

27 27 public Person)String nameofperson, int ageofperson( name = nameofperson; age = ageofperson; public void showdetails)( System.out.println)"name : " + name + "\nage : " + age(; class Jewish extends Person boolean britmila; // false if wasn't done true if was done boolean israeli; // false if not israeli true if israeli public Jewish)String nameofperson, int ageofperson, boolean brit, boolean israeliyesno(

28 28 name = nameofperson; age = ageofperson; britmila = brit; israeli = israeliyesno; public void showdetails)( super.showdetails)(; if )britmila( System.out.println)"Had BRIT MEELA"(; if )israeli( System.out.println)"is Israeli"(; class Christian extends Person boolean catolic; // false if not true if yes

29 public Christian)String nameofperson, int ageofperson, boolean catol( 29 name = nameofperson; age = ageofperson; catolic = catol; class Muslim extends Person boolean israeli; // false if not true if yes public Muslim)String nameofperson, int ageofperson, boolean fana( name = nameofperson; age = ageofperson; israeli = fana;

30 30 class SuperDemo1 public static void main)string args[]( Person human = new Jewish)"Jhon", 20, true, true(; // human holds a reference to // an object from the class Person Jewish zabar = )Jewish( human; // human goes through casting // and becomes a class variables // of the Jewish class type zabar.showdetails)(; מתודות מסוג final לשורת הכותרת של מתודה ניתן להוסיף את המילה השמורה,final ובכך למנוע את האפשרות שייעשה לה.overriding הודות להוספת מילה זו אל תחילת שורת הכותרת של המתודה )מייד אחרי הרשאת הגישה( לא ניתן יהיה להגדיר במחלקה היורשת את המתודה הזו מחדש. מתודה שהיא final מועברת בהורשה, מבלי שניתן יהיה להגדירה מחדש. דוגמא להגדרתה של מתודה כמתודת :final

31 31 public final void erasename)(... בהוספת המילה final לשורת הכותרת של מתודה יש שני יתרונות בולטים: עלייה בביצועים כאשר המתודה מוגדרת כמתודת final אין צורך לאתר את הגרסה המתאימה להפעלה כאשר יש קריאה להפעלתה )אין.)dynamically dispatching למתודה שמוגדרת כמתודה מסוג final לא ניתן לעשות,overriding ולכן כשהמחשב נתקל בה הוא לא צריך לחפש את המתודה המסוימת שעליו להפעיל. בדרך זו מושג חיסכון בזמן. הבטחה כי המתודה לא תשונה במחלקות שיורשות כאשר מתודה מוגדרת כמתודת final מובטח שהיא לא תשונה במחלקות היורשות. לעתים, בהגדרתן של מחלקות זוהי תכונה נדרשת. מחלקה מסוג final את המילה final ניתן גם להוסיף לשורת הכותרת של מחלקה. המשמעות היא שלא ניתן יהיה להגדיר מחלקה אחרת אשר תירש ממנה. מחלקה שמוגדרת כמחלקה מסוג final תוכל לרשת אך לא להוריש. את המילה final יש להוסיף לשורת הכותרת של המתודה מייד אחרי המילה שמייצגת את הרשאת הגישה שלה, ולפני המילה.class דוגמא:

32 32 public final class DeadMachine... בדוגמא זו, המחלקה DeadMachine לא יכולה להוריש. היא יכולה רק לרשת. אחת הדוגמאות למחלקה שמהווה חלק מהשפה, ושלא ניתן להגדיר מחלקה אשר תירש ממנה היא המחלקה.String מתכנני השפה רצו למנוע את האפשרות להגדיר מחלקה שתתאר מחרוזת תווים ותספק מתודות אשר לא קיימות במחלקה.String פעולתן של המתודות הבונות של מחלקות שיורשות מחלקות אחרות - Chaining Constructor כאשר נוצר אובייקט ממחלקה שיורשת ממחלקה אחרת, בפעולת יצירתו של האובייקט החדש תהיה גם הפעלה של ה- constructor ששייך למחלקה המורישה בנוסף להפעלת ה- constructor ששייך למחלקה שממנה נוצר האובייקט. אם המחלקה שממנה נוצר האובייקט יורשת ממחלקה אחרת ראשונה, והמחלקה האחרת הראשונה יורשת ממחלקה אחרת שניה וכך הלאה... בפעולת יצירתו של האובייקט החדש יופעל כל אחד מה- constructors של כל אחת מהמחלקות. הפעלת כל אחד מה- constructors נעשית באופן אוטומטי גם מבלי שב- constructors השונים תיכתב הקריאה להפעלתו של constructor מסוים. ה- constructor שיופעל כאשר אין קריאה ספציפית להפעלת constructor מסוים הוא

33 33 ה- constructor,default ולכן, אם הוא לא קיים )ה- constructor, default שהוא ה- constructor אשר לא מקבל ערכים בעת הפעלתו( אז תתרחש שגיאת קומפילציה. כדי לקרוא להפעלתו של constructor מסוים )במקום ה- constructor )default מבין ה- constructors שקיימים במחלקה המורישה יש לכתוב super ומייד אחריו בסוגריים את הערכים הנשלחים. על פי הערכים שנשלחים יופעל ה- constructor המתאים. התכנית הבאה מדגימה את אופן הקריאה להפעלתו של constructor מסוים באמצעות המילה.super class Person public String name; public int age; public Person)( this)"noname",18(; System.out.println)"The Person)( constructor"(; public Person)String nameofperson, int ageofperson( System.out.println)"The Person)String,int( constructor"(; name = nameofperson;

34 34 age = ageofperson; public void showdetails)( System.out.println)"name : " + name + "\nage : " + age(; class Jewish extends Person boolean britmila; // false if wasn't done true if was done boolean israeli; // false if not israeli true if israeli public Jewish)String nameofperson, int ageofperson, boolean brit, boolean israeliyesno( super)nameofperson,ageofperson(; System.out.println)"The Jewish constructor)string,int,boolean,boolean("(; britmila = brit; israeli = israeliyesno;

35 35 public void showdetails)( super.showdetails)(; if )britmila( System.out.println)"Had BRIT MEELA"(; if )israeli( System.out.println)"is Israeli"(; class Christian extends Person boolean catolic; // false if not true if yes public Christian)String nameofperson, int ageofperson, boolean catol( System.out.println)"The Christian constructor)string,int,boolean("(; name = nameofperson;

36 36 age = ageofperson; catolic = catol; class Muslim extends Person boolean israeli; // false if not true if yes public Muslim)String nameofperson, int ageofperson, boolean fana( System.out.println)"The Muslim constructor)string,int,boolean("(; name = nameofperson; age = ageofperson; israeli = fana;

37 37 public class ConstructorsDemo1 public static void main)string args[]( Person human = new Jewish)"Jhon", 20, true, true(; // human holds a reference to // an object from the class Person Jewish zabar = )Jewish( human; // human goes through casting and // becomes a class variables // of the Jewish class type zabar.showdetails)(; ניתן באמצעות תכנית זו גם להבחין בכך שסדר הפעלת ה- constructors מתחיל במחלקה הבסיסית ביותר, המחלקה שמורישה לאחרות, המחלקה,Person ואחר כך ממשיך לפי ההיררכיה במחלקות האחרות.

38 38 התכנית הבאה מדגימה את הקריאה להפעלת ה- constructor default של המחלקה המורישה אשר מתבצעת באופן אוטומטי כאשר נוצר אובייקט מטיפוס המחלקה היורשת )או כאשר מופעל ה- constructor שלו( וביצירתו)או בהפעלת ה- constructor שלו( אין קריאה מפורשת להפעלת constructor ספציפי של המחלקה המורישה. class Person public String name; public int age; public Person)( System.out.println)"The Person default constructor was called"(; public Person)String nameofperson, int ageofperson( System.out.println)"The Person)String,int( constructor was called"(; name = nameofperson; age = ageofperson; public void showdetails)( System.out.println)"name : " + name + "\nage : " + age(;

39 39 class Jewish extends Person boolean britmila; // false if wasn't done true if was done boolean israeli; // false if not israeli true if israeli public Jewish)String nameofperson, int ageofperson, boolean brit, boolean israeliyesno( System.out.println)"The Jewish )String,int,boolean,boolean(" + "constructor was called"(; name = nameofperson; age = ageofperson; britmila = brit; israeli = israeliyesno; public void showdetails)(

40 40 super.showdetails)(; if )britmila( System.out.println)"Had BRIT MEELA"(; if )israeli( System.out.println)"is Israeli"(; class Christian extends Person boolean catolic; // false if not true if yes public Christian)String nameofperson, int ageofperson, boolean catol( name = nameofperson; age = ageofperson; catolic = catol;

41 41 class Muslim extends Person boolean israeli; // false if not true if yes public Muslim)String nameofperson, int ageofperson, boolean fana( name = nameofperson; age = ageofperson; israeli = fana; class ConstructorsDemo2 public static void main)string args[]( Person human = new Jewish)"Jhon", 20, true, true(;

42 42 // human holds a reference to // an object from the class Person Jewish zabar = )Jewish( human; // human goes through casting // and becomes a class variables // of the Jewish class type zabar.showdetails)(; המתודה finalize אם המחלקה המורישה כוללת בתוכה מתודת finalize אז היא חייבת להיקרא באופן מפורש מתוך המתודה finalize שמוגדרת במחלקה היורשת. המתודה finalize ב- JAVA אינה דומה באופן פעולתה ל- destructors שקיימים ב C++. המתודה finalize אשר מוגדרת במחלקה המורישה לא תופעל באופן אוטומטי עם תום חייו של האובייקט שנוצר מהמחלקה היורשת. הקריאה להפעלת המתודה finalize תיעשה באמצעות המילה השמורה :super super.finalize)( שורה זו תיכתב בתוך המתודה finalize אשר תוגדר במחלקה היורשת.

43 43 Abstract Classes מחלקות אבסטרקטיות - מחלקות אבסטרקטיות הן מחלקות מבניות )שלדיות( שלא ניתן לייצור מהן אובייקטים. הדרך המקובלת להגדרתה של המחלקה כמחלקה אבסטרקטית היא הוספת המילה abstract לשורת הכותרת של המחלקה. לדוגמא: public abstract class Car... המחלקה Car היא דוגמא לאופן הגדרתה של המחלקה האבסטרקטית. את המילה abstract יש להוסיף אחרי המילה שמציינת את הרשאת הגישה ולפני המילה.class המחלקה האבסטרקטית משמשת כמחלקת בסיס, אשר ממנה מחלקות אחרות יירשו. הגדרת המחלקה האבסטרקטית יכולה לכלול בתוכה הגדרות של משתנים ומתודות. המתודות יכולות להיות מתודות אבסטרקטיות, כלומר, מתודות שלדיות שבתחילת שורת הכותרת שלה מופיעה המילה,abstract ובסופה במקום בלוק מופיע ; למתודה אבסטרקטית דומה למשמעות שיש לפונקציה וירטואלית טהורה ב- C++.. המשמעות שיש לדוגמא: public abstract class Shape

44 44 public abstract double area)(;... בעצם הגדרתה של מחלקה כמחלקה אבסטרקטית ניתן יהיה לחייב כי בכל אחת מהמחלקות שיירשו ממנה )מחלקות שיווצרו מהן אובייקטים... ) יידרסו המתודות האבסטרקטיות באמצעות מתודות חדשות שאינן אבסטרקטיות )שאם לא כן, אז גם מהמלחקה החדשה לא ניתן יהיה ליצור אובייקטים(. המחלקה האבסטרקטית לא חייבת לכלול בתוכה רק מתודות אבסטרקטיות. היא בהחלט יכולה לכלול בתוכה גם מתודות שאינן אבסטרקטיות )מתודות עם גוף(, והיא בהחלט יכולה לכלול בתוכה גם הגדרות של משתנים והגדרות של.construcros מהמחלקה האבסטרקטית לא ניתן לייצור אובייקטים. יש צורך להגדיר מחלקה אחרת אשר תירש מהמחלקה האבסטרקטית, ובה יש להגדיר באופן מסודר את המתודות שהוגדרו כמתודות אבסטרקטיות במחלקה האבסטרקטית, שאם לא כן, אז גם המחלקה היורשת תיחשב למחלקה אבסטרקטית, וגם ממנה לא ניתן יהיה לייצור אובייקטים. Interface ממשק הקדמה למרות ש- JAVA לא תומכת בהורשה מרובה, קיימת ב- JAVA האפשרות להגיע לתוצאות, שדומות לאלה שמושגות באמצעות הורשה מרובה, באמצעות השימוש ב- Interfaces.,public בעלות הרשאת הגישה )abstract( היא מחלקה מדומה שיכולה להכיל אך ורק מתודות אבסטרקטיות Interface ומשתנים שהם static ו-.final

45 45 ניסיון לייצור משתנה שאיננו עומד לכאורה בקריטריונים אלה יתברר כניסיון שתוצאתו בכל זאת משתנה מסוג final ו-.static המתודות שמוגדרות ב- interface לא יכולות להיות: native, static, synchronized, final, private או.protected אופן השימוש ב - Interfaces הגדרת ה- interface נעשית באופן הבא: interface InterfaceName כל המתודות שמוגדרות חייבות להיות abstract ועם הרשאת הגישה! public כל המשתנים חייבים להיות static ו-! final ניתן גם להוסיף בתחילת שורת ההגדרה הרשאת גישה. ה- interface יכלול מתודות ומשתנים שנרצה שיתממשו במחלקות שיישמו אותו. כדי שמחלקה תממש interface מסוים שהגדרנו יש לעשות שימוש במילה השמורה implements באופן הבא: בסוף שורת הכותרת של המחלקה יש לרשום implements ואחריה את שמו של ה- interface המיושם. דוגמא: public interface Aircraft

46 46... public class Car... public class SportCar extends Car implements Aircraft... המחלקה SportCar יורשת מהמחלקה Car ובכך ניתן לומר כי כל המשתנים והמתודות שהוגדרו במחלקה Car יהיו קיימים גם במחלקה SportCar באופן אוטומטי משום ההורשה. כיוון שבהגדרת המחלקה SportCar מיושם גם ה- interface ששמו Aircraft כל המתודות שהוגדרו באותו interface חובה יהיה להגדירן במחלקה.SportCar אלה הן מתודות אבסטרקטיות שאם הן לא יוגדרו במחלקה SportCar אז המחלקה SportCar תהיה גם אבסטרקטית, ובתור שכזו לא ניתן יהיה לייצור ממנה אובייקטים. כמו כן, כל הקבועים הסטטיים שיוגדרו ב- interface ניתן יהיה להשתמש בהם במחלקה SportCar אשר מיישמת את אותו.interface כיוון שכך, ניתן לומר כי בכל אובייקט מטיפוס המחלקה SportCar קיימים כל המשתנים הקבועים שהוגדרו ב- interface

47 47 ששמו,Aircraft וכמו כן, כי על כל אובייקט ניתן להפעיל את כל אחת מהמתודות שהוגדרו ב- interface ששמו.Aircraft מסיבה זו ניתן יהיה לאחסן reference לאובייקט מטיפוס המחלקה SportCar במשתנה מטיפוס ה- interface ששמו.Aircraft ובהמשך לדוגמא, השורה הבאה אפשרית לכתיבה: CarEngine sportengine = new SportCar)(; כדאי לשים גם לב לעובדה שבאמצעות המשתנה sportcar ניתן יהיה להפעיל אך ורק את המתודות שהוגדרו ב- interface ששמו,Aircraft כיוון שהמשתנה sportengine מהטיפוס.CarEngine הכלל הקובע בהפעלת מתודות באמצעות משתנים הוא שניתן להפעיל אך ורק את המתודות שמוגדרות ב- interface/class שמטיפוסו נוצר המשתנה. השימוש ב- interfaces מקנה את היכולת להגדיר מחלקות שיונקות את תכונותיהן ופעולותיהן מיותר ממקור אחד, מבלי להסתבך בהיררכית מחלקות מסובכת, מבלבלת ובעייתית. ניתן להגדיר מחלקה שתיישם יותר מ- interface אחד. אם המחלקה מיישמת יותר מ- interface אחד אז יש לרשום את שמות ה- interfaces בצירוף פסיקים מפרידים. דוגמא: class SportCar extends Car implements Aircraft, Tank, Ship...

48 48 התכנית הבאה מדגימה שימוש פשוט ב- interfaces : Interfaces לצורך סימון ניתן להגדיר Interface שלא מוגדרת בו אף מתודה ואף קבוע, ושמטרתו היחידה לסמן את המחלקה שמיישמת אותו. סימון מחלקה באמצעות Interface שמיושם בהגדרתה נעשה אודות למילה השמורה.instanceof באמצעות instanceof ניתן לדעת אם אובייקט נתון נוצר ממחלקה שמיישמת Interface מסוים... או לא... ולטפל בו בהתאם. משפט התנאי: if )referencetoanobject instanceof InterfaceName(... יהיה true אם האובייקט נוצר ממחלקה שבהגדרתה יושם ה- Interface ששמו צוין. אופן השימוש המלא במילה השמורה instanceof יוסבר בהמשכו של הפרק. אחת הדוגמאות ל- Interface שמשמש לסימון מחלקות הוא ה- Interface ששמו:.Cloneable שינוי טיפוס - Types Casting between Class כפי שכבר ראינו, אין כל בעיה לאחסן reference לאובייקט במשתנה מטיפוס המחלקה שהורישה למחלקה שממנה האובייקט נוצר. לדוגמא: Car mycar = new SportCar)(; באופן דומה, ראינו גם כי אין כל בעיה לשלוח למתודה שמצפה לקבל reference מטיפוס מסוים reference לאובייקט מטיפוס מחלקה שיורשת מאותו טיפוס מסוים.

49 ה. ה. ה. ה. 49 באופן כללי ניתן לומר כי ביצוע הפעולות שהפוכות לפעולות שתוארו לעיל איננו אפשרי. לא ניתן לאחסן בתוך משתנה מטיפוס מסוים reference מטיפוס שהוריש לטיפוס של אותו משתנה. באופן דומה, לא ניתן לשלוח למתודה reference מטיפוס שהוריש לטיפוס הפרמטר של אותה מתודה. עם זאת, לעתים הפעולות שתוארו לעיל אפשריות בכל זאת. המקרים שבהם הן מתאפשרות הם אותם מקרים שבהם ה- reference מטיפוס ששונה מטיפוס האובייקט. לדוגמה, reference מטיפוס Car לאובייקט מטיפוס SportCar ייחשב מטיפוס Car כיוון שהוא מאוחסן במשתנה מטיפוס.Car אם את אותו reference מנסים להכניס למשתנה מטיפוס,PrivateCar והמחלקה PrivateCar יורשת מ- Car, ומורישה ל- SportCar, אז השמת ה- reference אל תוך המשתנה מטיפוס PrivateCar יכולה להתאפשר, ובלבד שיבוצע ל- reference שינוי טיפוס )casting( כך שיהיה מטיפוס SportCar נוצר מהמחלקה מכוון מתאפשר כיוון שהאובייקט שאליו ה- reference casting- Car במקום PrivateCar )מחלקה שיורשת מ- PrivateCar (. כל המשתנים והמתודות שקיימים בטיפוס PrivateCar קיימים גם בטיפוס.SportCar ביצוע casting ל- reference מתאפשר אך ורק אם תוצאות הבדיקה הבאה :true referencetoobject instanceof class/interfacename ערכו של הביטוי הלוגי הנ"ל,true אך ורק אם ה- reference ממלא את אחד התנאים הבאים: reference- הוא לאובייקט מטיפוס המחלקה ששמה מצוין 1 reference- הוא לאובייקט מטיפוס מחלקה שיורשת מהמחלקה ששמה מצוין 2 reference- הוא לאובייקט מטיפוס מחלקה שמיישמת את ה- interface ששמו מצוין 3 בכל אחד מהמקרים הנ"ל ערכו של הביטוי יהיה,true ולכן, ניתן יהיה לבצע ל- reference האמור casting כך שישנה את טיפוסו ויהיה מטיפוס המחלקה או ה- interface ששמם צוין בפקודת ה- instanceof.

50 50 דוגמא: נניח את קיומן של המחלקות: Car, SportCar ו- PrivateCar ואת קיומו של ה- interface CarEngine: אשר מיושם על ידי המחלקה.Car הנח גם כי המחלקה Car מורישה למחלקה PrivateCar וכי זו מורישה למחלקה.SportCar כמו כן, הנח כי נוצרו האובייקטים הבאים: Car c1 = new Car)(; Car c2 = new SportCar)(; תחת הנחות אלה ניתן לסכם ולומר כי ערכו של כל אחד מהביטויים הבאים הנו: )c2 instanceof Car( - true )c2 instanceof SportCar( - true )c1 instanceof CarEngine( - true )c2 instance of CarEngine( - true )c1 instanceof SportCar( - false וכן הלאה... יש לזכור, כי ה- casting נעשה רק לטיפוס של ה- reference. האובייקט לא משתנה ולא משנה את טיפוסו. רק ה- reference אליו משנה את טיפוסו. הפיכת ערך מטיפוס בסיסי לאובייקט ולהפך Converitng Primitive Types to Objects & Vice Versa לא ניתן לבצע casing לערך מטיפוס בסיסי כך שיהפוך להיות אובייקט או reference לאובייקט. עם זאת, ב-: package java.lang קיימות מספר מחלקות שמשמשות ליצירת אובייקטים שיכולים לייצג את כל אחד מהטיפוסים הבסיסיים. שמן של מחלקות אלה מעיד על ייעודן.

51 51 לדוגמא: Integer Float Boolean וכך הלאה... באמצעות המתודות שמוגדרות בתוך כל אחת מהמחלקות אלה ניתן לייצור מכל אחת מהן אובייקט אשר יקביל לאחד הטיפוסים הבסיסיים שקיימים ויתאר ערך בסיסי מסויים. כל מחלקה מבין קבוצת מחלקות אלה משמשת ליצירת אובייקט שיכול לתפקד בדומה לערך מטיפוס בסיסי מסוים כלשהו. דוגמא: public class PrimitiveDemo public static void main)string args[]( Integer intvar = new Integer)70(; int number = intvar.intvalue)(; System.out.println)"intVar="+intVar(; System.out.println)"number="+number(; number = Integer.valueOf)"2341"(.intValue)(; System.out.println)"number="+number(;

52 52 המתודות שתם זמנן - Deprecation מתודות אשר בעקבות התפתחותה של השפה וקביעתם של סטנדרטים חדשים במתן שמות פעולותיהן ותפקידיהן מבוצעים באמצעות מתודות אחרות. ב- JAVA מתודות אלה נחשבות ל- deprecated. כאשר מהדרים תכנית ב- JAVA ובתכנית נעשה שימוש ב-מתודות אשר נחשבות ל- deprecated מקבלים על כך הודעת הזהרה מתאימה.)warning( אם רוצים, ניתן להדר את קובץ קוד המקור בתוספת התגית deprecation ובדרך זו לקבל מידע יותר מפורט על המתודות שנחשבות למיושנות. דוגמא: כתיבת שורה זו בביצוע ההידור לקובץ קוד המקור הבא תגרום להצגת הסברים מפורטים על המתודות המיושנות שנעשה בהם שימוש בקוד. javac deprecation DeprecatedDemo.java import java.util.*; public class DeprecatedDemo public static void main)string args[](

53 53 Date birthday = new Date)1970,1,12(; System.out.println)birthday(; כדאי להשתדל ולהימנע מלהשתמש במתודות שנחשבות ל- deprecated כיוון שבהחלט ייתכן שעם התפתחותה של השפה אותן מתודות ומחלקות שנחשבות ל- deprecated יוצאו מהשפה )"צא בחוץ!"(. מחלקות מוכנות ליצירת מבני נתונים ב- JAVA קיימות מחלקות מוכנות, שאובייקט מטיפוסן יכול לשמש בתור,container משמע, אובייקט מטיפוס כל אחת מהן יכול לשמש בתור אובייקט שמחזיק בתוכו נתונים אחרים במבנה מסוים. המחלקות שבולטות בקבוצה זו הן: Vector Stack Hashtable LinkedList וזוהי רק חלק מהרשימה. ה- references לאובייקטים שמהווים נתונים אשר מוחזקים על ידי אובייקט שנוצר מאחת המחלקות הללו, מוחזקים במשתנים מטיפוס Object ולכן יש לזכור לבצע casting מתאים ובהתאם לצורך כאשר משתמשים במתודות שמוגדרות במחלקות אלה. מתודות אלה מוגדרות - בדרך כלל - כמתודות שמחזירות reference מטיפוס,Object אשר יש לבצע לו casting בהתאם לאופן השימוש באובייקט.