חברים בהֵדגֵם, חברים במחלקה,

בנאים וביצוע סיום finalization) )

- מבוא

- הקדמה

- משתני מופע

- משתני מחלקה

- מתודות המופע

- מתודות המחלקה

- בנאים

- ביצוע סיום

- שאלות סיכום

מבוא

סטודנטים בקורס הקדמה לתכנות Java אחראים לידיעת והבנת כל החומר בשעור זה
(חוץ מנושאים ספציפיים ב – C++).

הנושאים הספציפיים ב – C++ מוצעים כחומר משלים לטובת אלו שמכירים כבר C++
ומבצעים הסבה ל – Java.

הקדמה

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

השיעור גם יעניק תובנות חדשות לגבי בנאים.

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

משתני מופע

הן ב‑Java והן ב‑++C, ההצהרה על משתנה חבר (נתון-חבר) במחלקה בתוך הגדרת המחלקה, מבלי להשתמש במילת המפתח static, גורמת ליצירת משתנה המופע באובייקטים של אותה מחלקה. (הצהרה המשתמשת במילת המפתח static, מציינת משתנה מחלקה.)

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

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

מכאן נובע שמם.

ב‑Java אנו ניגשים למשתני המופע, המשויכים עם אובייקט מסוים, על ידי צירוף שם האובייקט לשם המשתנה, כשהם מופרדים בנקודה (מחברים אחדים מציינים את הנקודה כאופרטור נקודה),
כמו בדוגמה הבאה:

myObject.myInstanceVariable

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

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

myPointerVariable -> myInstanceVariable

משתני מחלקה

הן ב‑Java והן ב‑++C, ההצהרה על נתון-חבר בתוך מחלקה תוך שימוש במילת המפתח static, גורמת ליצירת משתנה מחלקה.

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

ב‑++C עליך "להצהיר מחדש" על כל משתני המחלקה מחוץ להגדרת המחלקה, ובכך ליצור כביכול משתנה גלובלי, כלומר משתנה גלובלי ככל הנוגע לאובייקטים של אותה מחלקה.
"הצהרה מחדש" כזו אינה נחוצה ב‑Java. .

לו יכולנו לבחון את הזיכרון שהוקצה עבור כל אובייקט, היינו מגלים שכל האובייקטים חולקים ביניהם את הזיכרון, שבו מאוחסן כל משתנה מחלקה. אם כי אינני בטוח כיצד זה נעשה הלכה למעשה ב‑Java, יש לשער שהזיכרון, המוקצה עבור כל אובייקט, מכיל גם מעין מחוון או הצבעה אשר מצביעים על המקום בזיכרון, שבו מאוחסן משתנה המחלקה הממשי.

דבר חשוב נוסף לגבי משתני מחלקה הוא , שהן ב‑Java והן ב‑++C, ניתן לגשת למשתני מחלקה תוך שימוש בשם המחלקה ובשם המשתנה. אין צורך ליצור אובייקט של המחלקה על מנת לגשת למשתני המחלקה שלה.

ב‑Java הגישה למשתני מחלקה נעשית תוך שימוש בשם המחלקה ובשם המשתנה,
כשהם מופרדים על ידי אופרטור הנקודה. קטע הקוד הבא ניגש למשתנה מחלקה בשם out של המחלקה בשם System. תוך כדי כך הוא ניגש למתודת println של משתנה המחלקה על מנת להציג מחרוזת בהתקן הפלט הסטנדרטי.

System.out.println("Display my string");

ב‑++C הגישה למשתני מחלקה נעשית באמצעות האופרטור scope resolution יחד עם שם המחלקה ושם המשתנה, כמתואר למטה:

MyClass::myClassVariable

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

זכור, כי היות וכל האובייקטים של המחלקה חולקים ביניהם את משתני המחלקה, הרי שאם אובייקט כלשהו ישנה אותם, השינוי תקף מבחינת כל האובייקטים של אותה מחלקה.
ניתן להשתמש בכך כמעין תקשורת בין האובייקטים.

ב‑Java מרבים להשתמש במשתני מחלקה עם מילת המפתח final, וזאת כדי ליצור משתנים שיתנהגו כקבועים. מבחינת הזיכרון, זוהי שיטה חסכונית, משום שאין צורך במספר עותקים של אותו קבוע.

מתודות המופע

כאשר אתה כולל פונקציה חברה בתוך הגדרת המחלקה ב‑++C, או כולל מתודה בהגדרת המחלקה ב‑Java, מבלי להשתמש במילת המפתח static, התוצאה תהיה שאובייקטים של המחלקה יכילו מתודת המופע.

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

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

מתודות מופע מופעלות ב‑Java על ידי צירוף שם האובייקט לשם המתודה באמצעות אופרטור הנקודה, כפי שמציגה הדוגמה הבאה:

myObject.myInstanceMethod( )

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

myObjectPointer -> myInstanceMethod( )

שים לב, שלמתודות המופע יש גישה הן למשתני המופע והן למשתני מחלקה ב‑Java וגם ב‑++C.

מתודות מחלקה

כאשר פונקציה חברה נכללת בהגדרת המחלקה ב‑++C, או כשמתודה נכללת בהגדרת המחלקה ב‑Java, תוך שימוש במילת המפתח static, נוצרת מתודת מחלקה.

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

ב‑Java ניתן להפעיל מתודת מחלקה על ידי צירוף שם המחלקה לשם המתודה באמצעות אופרטור הנקודה, כמתואר למטה:

MyClass.myClassMethod()

ב‑++C ניתן להפעיל מתודת מחלקה תוך שימוש בשם המחלקה, באופרטור scope resolution ובשם המתודה, כמתואר למטה:

MyClass::myClassMethod()

ב‑Java למתודות מחלקה יש גישה רק לחברים אחרים במחלקה: משתני מחלקה ומתודות מחלקה אחרות. למתודות מחלקה אין גישה למשתני המופע של המחלקה, אלא אם כן הן יוצרות אובייקט חדש וניגשות למשתני המופע באמצעות אותו אובייקט.

דרישות דומות תקפות גם לגבי ++C .