מחלקה מסוג Static Class
static במחלקות: משתנה, פונקציה ומחלקה סטטיים, וגם בנאי סטטי. כולם שייכים למחלקה עצמה ולא לאובייקט מסוים.public static int Counter נפתח פעם אחת באזור זיכרון משותף, ולא בכל אובייקט. הגישה אליו נעשית בעזרת שם המחלקה, למשל Product.Counter.static הוא סוג של הרשאה. למעשה משתנה סטטי יכול להיות public או private, וה-static רק קובע שהוא לא שייך לאובייקט.private, ומבחוץ קוראים ממנו בעזרת פרופרטי סטטי לקריאה בלבד. כך מתכנת אחר לא יכול לשנות אותו בטעות. גם הפרופרטי צריך להיות סטטי.CalculateSum שמקבלת מערך לא צריכה אובייקט, ולכן נקראת דרך שם המחלקה. מחלקה שכל חבריה סטטיים מוגדרת כ-static class, ואי אפשר ליצור ממנה אובייקט.this. לעומת זאת פונקציה לא סטטית יכולה לגשת לכל משתנה סטטי.static Product() רץ פעם אחת, לפני השימוש הראשון במחלקה, ומשמש לאתחול של משתנים סטטיים. אין לו הרשאת גישה ואין לו פרמטרים.Main סטטית, כדי שמערכת ההפעלה תריץ אותה בלי ליצור אובייקט מהמחלקה.פרקי ההרצאה: מחלקה מסוג Static Class
תמלול ההרצאה: מחלקה מסוג Static Class
הטקסט המלא של הדקות הראשונות בהרצאה «מחלקה מסוג Static Class» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
הכלי הבא שאנחנו הולכים לראות באובג'קט אוריינטד זה כלי מאוד מאוד חשוב שהרבה פעמים הוא איזשהו מקור לבלבול עבור מתכנתים מתחילים וזאת המילה השמורה סטטיק אז בואו נראה מה זה אומר יש לנו כאן את הפרויקט של המוצרים ויש לנו פה פתיחה של אובייקט ראשון אובייקט מוצר והיא הכנסת ערכים יש לנו פתיחה
של אובייקט שני וכאן אנחנו מכניסים ערכים בקונסטרקטור ובואו נניח שאנחנו קיבלנו הוראה ואנחנו צריכים איזשהו משתנה שיספור כמה אובייקטי פרודקט קיימים בתוכנית.
כלומר, כמה מוצרים כרגע קיימים בתוכנית. ואנחנו צריכים לסתוך את המשתנה הזה ולספור כמה מוצרים קיימים במהלך פעילות התוכנית. עכשיו, בין אם יש לנו מוצר אחד או שני מוצרים או אלף מוצרים, בשביל לספור אותם אנחנו צריכים סך הכל משתנה אחד ויחיד שיספור אותם.
אז נראה שזה ממש לא בעיה ללכת לפה ולרשום int counter, ללכת אותו באפס וברגע שיוצרים איזשהו מוצר כל מה שצריך לעשות זה ללכת לקאונטר ולהעלות אותו באחד והנה כאן אנחנו יצרנו עוד מוצר ואנחנו יכולים פה להעלות אותו עוד פעם כי יצרנו עוד מוצר ולכן אנחנו יכולים בסופו של דבר להדפיס מספר המוצרים שקיימים לנו והקאונטר בואו נסתכל ונראה שאכן
יש לנו שני מוצרים קיימים אנחנו רואים פה שיש את הקונסטרקטור שבנינו בסרטון הקודם עדיין קיים במחלקה אוקיי אז מה בדיוק הבעיה בפתרון שנתנו כרגע אז כמובן פתרון הזה הוא פתרון תכנותי גרוע למה מפני שאנחנו רוצים שקוד שאנחנו כותבים או איזשהו דיזיין שאנחנו עושים יעבוד תמיד ופה מה שעשינו זה אמרנו אם אתה רוצה לפפור את כל המוצרים בתוכנית
בכל מקום שאתה הולך לפתוח אובייקט מוצר פשוט תעלה את הקאונטר אבל האם מי שעובד עם התוכנית אחר כך מתכנת ב' הולך באמת לבכור להעלות את הקאונטר ומה קורה אם מתכנת ב' נמצא בכלל באיזושהי פונקציה אחרת שנקראת do something ובתוך הפונקציה האחרת הזאת הוא הולך ובונה איזשהו אובייקט מוצר חדש כעת כבר יש בתוכנית שלושה מוצרים והקאונטר
בכלל לא מוכר בפונקציה אחרת כלומר הוא מוכר רק באזור של המיין אז אנחנו רואים שהפתרון הזה הוא לא פתרון טוב מכמה סיבות סיבה אחת איפה הקאונטר בכלל מוכר רק באזור שבו הוא נפתח סיבה שנייה אף אחד לא אמור לזכור להעלות את הקאונטר וזה גם לא התפקיד שלו זאת אומרת הפתרון הזה הוא פתרון ממש ממש בעייתי ולכן אנחנו לא נבצע
אותו בואו ניפטר מהקאונטר אז איך בעצם עושים את זה אז למעשה מה שאנחנו אמורים לעשות זה להבין הקאונטר הזה שאנחנו רוצים לפתוח, הסכימה של כל המוצרים שקיימים בתוכנית, זו פעילות שהמחלקה פרודקט צריכה לטפל בה, ולכן אותו משתנה צריך להיות בעצם במחלקה פרודקט.
אז בואו ניגש למחלקה פרודקט ונסתכל על הדאטה ממברס שקיימים פה, ואולי באמת כדאי לנו להוסיף כאן את אותו משתנה. כרגע נעשה אותו בהרשאת גישה public כי אנחנו רוצים לגעת בו גם מבחוץ.
אז בואו נפתח public int counter, נכניס לתוכו איזשהו אפס והאם עכשיו באמת עשינו את הדבר הנכון ופתחנו את המשתנה במקום הנכון.
אז בואו נסתכל רגע מה בעצם עשינו כאן. כאשר אנחנו יצרנו data member בתוך מחלקת product שנקרא product name זה אומר שמשתנה product name יהיה בכל אחד מהאובייקטים העתידיים שיפתחו מהמחלקה product.
כאן אנחנו רואים שיש לנו שני אובייקטים ולכן לשני האובייקטים האלה קיים משתנה Product Name בנפרד, וזה ממש הגיוני שזה מה שיקרה. כאשר אנחנו פתחנו כאן את Category Name אנחנו רצינו בדיוק את אותו הדבר, שלכל אחד מהמשתנים העתידיים מסוג Product יהיה שם קטגוריה שיכול להיות נפרד.
במקרה שני המוצרים שתמיד אנחנו מתעסקים איתם הם פירות, אז השם זה Fruit, אבל עדיין אנחנו רוצים שלכל אחד מהמוצרים, מהאובייקטים העתידיים של המוצרים, יהיה קטגורי ני משלו אותו הדבר פרייס אנחנו הגדרנו data member שנקרא פרייס וזה אומר שלכל אחד מהאובייקטים העתידיים יש מוצר נפרד קטע זיכרון משלו וזה בדיוק מה שעשינו פה עם הקאונטר ולכן
לכל אחד מהאובייקטים העתידיים יש counter נפרד זאת אומרת אם אנחנו הולכים לכאן first product נקודה אנחנו רואים שיש לנו counter וזה משתנה שהוא נפרד לגמרי מהמשתנה second product נקודה counter שאני לא רואה את האינטליסנס כי יש לי פה שגיאת קומפילציה נקודה counter וזה שני משתנים נפרדים לגמרי ולא המצב שאנחנו
רוצים להגיע אליו אנחנו בעצם רוצים שיהיה לנו משתנה אחד ויחיד שיספור את כל המוצרים בואו נסתכל רגע מה קורה בעצם בזיכרון בדיזיין שעשינו עכשיו אז יש לנו פה בעצם את המחלקה product שמכילה product name, CategoryName ו-Price ואנחנו הלכנו ויצרנו מוצר אחד והשתמשנו בו בקונסטרקטור הריק זה אומר שיש לנו כאן אובייקט אחד ויחיד ובתוכו
יש את הערכים האלה לאחר מכן הלכנו ויצרנו מוצר שני השתמשנו פה עם הקונסטרקטור המלא ולאחר מכן יש לנו כאן אובייקט נוסף עם הערכים שנמצאים בו כאשר אנחנו הלכנו והוספנו את המשתנה public int counter כdata member רגיל לגמרי בתוך מחלקת product מה שבעצם עשינו זה כמו הdata member הקודמים הוספנו למחלקה עוד תא זיכרון עבור כל אחד
מהאובייקטים העתידיים שיפתחו מהמחלקה הזאת זאת אומרת מי שבנה את המחלקה product זה מתכנת א', מתכנת ב' בעתיד הולך לפתוח אובייקטים ממנה אז כל אובייקט עתידי שהולך להיפתח first product second product וכולי יהיה לו data member נפרד שנקרא counter בדיוק כמו שיש לו data member שנקרא product name ולכן לכל אחד מהאובייקטים יהיה counter זה
לא מה שאנחנו רוצים אנחנו רוצים counter אחד ויחיד אז כמובן הפתרון הזה גם לא טוב בואו נחזור בחזרה ונראה מה כן ניתן לבצע אנחנו צריכים להבין שבתוכנית שלנו יש כל מיני אזורי זיכרון שהתוכנית עובדת איתם אזור זיכרון אחד ואזור זיכרון של האובייקטים עצמם שהולכים להיפתח אבל האזור הזיכרון הזה
מחולק למעין אזור זיכרון נוסף שנקרא Static Segment. Static Segment זה אזור זיכרון שאנחנו יכולים לפתוח משתנים בתוך קלאס אבל הם לא יהיו חלק מהאובייקטים אלא ייפתחו בנפרד פעם אחת באזור הזיכרון Static Segment. איך עושים את זה?
עושים את זה בעזרת המילה Static וכאן אנחנו פעם ראשונה רואים באמת מה המשמעות שלה. עכשיו, שימו לב, יש בלבול אצל מתכנתים מתחילים באובג'קט אוריינטד, שחושבים שסטטיק זה סוג של הרשעת גישה.
סטטיק זה לא הרשעת גישה, זה לא קשור ל-public, זה לא קשור ל-private. משתנה שהוא סטטיק, כל מה שהוא אומר, שהוא נפתח פעם אחת ויחידה בתוך אזור הזיכרון סטטיק סגמנט, ולא כחלק מכל אובייקט עתידי שיפתח במחלקה.
משתנה סטטי, יכול להיות public הוא יכול להיות private הוא יכול להיות בכל הרשאת גישה אחרת שקיימת אז בעצם ברגע שפתחנו פה public static integer counter המשתנה הזה כבר לא נמצא כחלק מכל אובייקט אלא הוא נמצא אחד ויחיד בתוך אזור הזיכרון הסטטיק סגלר ועכשיו השאלה איך אנחנו ניגשים אליו מפני שאם הוא היה חלק מהאובייקט
אז בשביל לגשת אליו כל מה שהיינו צריכים לעשות זה לרשום את שם האובייקט נקודה ואז את שם המשתנה בדיוק כמו שכאן אנחנו רואים שיש לנו שם object first product נקודה product name יש לנו גישה למשתנה product name שנמצא פה.
אז התשובה היא כזאת אם אנחנו נמצאים בתוך המחלקה product ואנחנו רוצים לגשת למשתנה הסטאטי קאונטר כל מה שאנחנו צריכים לרשום זה פשוט את המילה counter שאנחנו רואים פה למטה אם אנחנו נמצאים מחוץ למחלקה ואנחנו רוצים לגשת למשתנה הסטטי counter אז הגישה אליו לא יכולה
להתבצע דרך אובייקט מהמחלקה מפני שהוא לא שייך לאובייקט אלא הגישה אליו צריכה להתבצע דרך שם המחלקה עצמה. לדוגמה product.counter כך אנחנו ניגשים אליו מבחוץ אז בואו עכשיו נחזור לקוד וניישם את זה אז כל מה שאנחנו צריכים לעשות זה להפוך את המשתנה הזה לסטטיק וכעת אם אנחנו הולכים לפרסט פרודקט נקודה שימו לב שאתם לא הולכים למצוא אותו
פה אין לפרסט פרודקט אובייקט קאונטר או משתנה קאונטר ואין לאף אחד מהאובייקטים של פרודקט משתנה קאונטר אם אנחנו רוצים לגשת אליו פרודקט נקודה קאונטר אוקיי אבל איך עדיין אנחנו דואגים שהערך הזה תמיד יחזיק לנו את מספר האובייקטים שקיימים מהמחלקה product,
כי מה שעשינו עד עכשיו, עשינו בעצם שני דברים נכונים. א', הגדרנו משתנה אחד ויחיד, הוא קיים במקום אחד בתוך המחלקה, המחלקה צריכה לטפל בנקודה הזאת ולכן הוא קיים בתוך המחלקה.
הדבר השני, הפכנו אותו לסטטיק בכדי שהוא יופיע פעם אחת ולא ישוכפל עבור כל אובייקט. ואנחנו צריכים עכשיו לדאוג שתמיד הערך שלו יכיל את כמות האובייקטים שנפתחו לנו בקוד.
פשוט מאוד כל מה שאנחנו צריכים לעשות זה לגשת לאזור קוד שמתבצע בכל פעם שאובייקט נוצר ולהעלות את הקאונטר באחד.
איזה אזור זיכרון מתבצע או איזה פונקציה מתבצעת כל פעם שאובייקט נוצר בזיכרון? ניחשתם נכון? הקונסטרקטורים.
והשאלה היא איזה קונסטרקטור מבין שלושת הקונסטרקטורים האלה אנחנו צריכים להעלות את הקאונטר באחד? והתשובה היא כזאת: אנחנו צריכים לדאוג לזה שלא משנה באיזה קונסטרקטור מתכנת ב' יחליט לפעול או לקרוא לו, עדיין כל יצירת אובייקט תעלה את הקאונטר באחד בלבד.
אז אנחנו רואים שאם מתכנת ב' בוחר לפתוח אובייקט בעזרת הקונסטרקטור הריק, אנחנו צריכים להעלות את הקאונטר באחד. אם הוא מחליט להעלות את הקאונטר בעזרת הקונסטרקטור שמקבל שני ערכים, אנחנו צריכים להעלות את הקאונטר באחד כי אין ביניהם שום קשר אם הוא מחליט להעלות את ה...
להשתמש בקונסטרקטור שמקבל שלושה ערכים ואנחנו נחליט גם כאן להעלות את הקאונטר אז תהיה לנו פה איזושהי בעיה שנקראת באג על הקאונטר הזה ומה הבעיה?
הבעיה היא שכאשר הוא קורא לקונסטרקטור שמקבל שלושה ערכים אנחנו רואים שישנה קריאה לקונסטרקטור שמקבל שני ערכים ולכן הקאונטר יעלה פעמיים עבור פתיחת אובייקט אחד זאת הסיבה שאנחנו לא נעלה אותו כאן.
וכעת כל הקונסטרקטורים באמת תומכים בהעלאה של הקאונטר. עכשיו בואו נציג אותו ונראה האם הוא מציג לנו ערכים נכונים. אז בואו נציג את הקאונטר כאן product.counter.
כלומר הצגנו אותו בדיוק אחרי שיצרנו מוצר אחד. בואו נריץ ואנחנו רואים שהקאונטר הוא 1. בואו נחזור על הקוד הזה ונדפיס אותו כאן.
אנחנו רואים שיש לנו כבר שני מוצרים. מה יקרה אם אנחנו נדפיס אותו כאן? האם אנחנו יכולים להגיע למשתנה סטטי לפני שבכלל יש לנו אובייקט מהמחלקה? בואו נריץ.
והתשובה היא כמובן כן, מפני שמשתנה סטטי לא קשור בכלל לאובייקט מהמחלקה ולכן אין לנו שום בעיה לגשת אליו בלי בכלל שקיים שום אובייקט מהמחלקה.
אוקיי, שימו לב שכאשר אובייקט מהמחלקה נהרס אולי כדאי לנו בדיסטרקטור לגשת לקאונטר ולהוריד אחד מהקאונטר זה אומר שאין לנו יותר אובייקט, אוקיי אז בואו נוריד אחד אבל שימו לב שהדבר הזה לא ייתן לנו באמת תמונה
מדויקת לגבי כמה אובייקטים של פרודקט קיימים כרגע בתוכנית מפני שמי שקורא לדיסטרקטור כמו שדיברנו זה הגארבץ' קולקטור וה garbage collector קורא לדיסטרקטור מתי שהוא מוצא לנכון לפרק לנו את האובייקט או לשחרר אותו מהזיכרון או להרוס אותו.
ואנחנו לא יכולים לדעת מתי זה בדיוק יקרה. יכול להיות שהוא יעשה את זה אפילו בסוף התוכנית שכבר זה לא רלוונטי. אבל אנחנו יכולים לעשות את זה רק בשביל ההדגמה.
דבר נוסף, אנחנו רואים כאן שיש לנו שוב פעם קריאה לcounter++ העלאת הcounter וגם כאן. אנחנו יכולים לחסוך את זה על ידי שימוש בקונספט של רשימת אתחול.
בואו נסתכל מה זה אומר. אם מישהו קורא לקונסטרקטור של השלושה ערכים מתבצעת קריאה לקונסטרקטור של השני ערכים. אם מישהו קורא לקונסטרקטור של השני ערכים אנחנו יכולים לקרוא לקונסטרקטור שמקבל אפס ערכים ולכן זה חוסך לנו את העלאת הקאונטר פה.
בעצם פעם אחת בקונסטרקטור הדיפולט אנחנו מעלים את הקאונטר. אם מישהו קורא לקונסטרקטור של הקונסטרקטור הריק יש לנו העלאה של counter מי שקורא לקונסטרקטור שמקבל שני ערכים קודם כל אנחנו קוראים לריק בשביל לראות את הקאונטר ואז ממשיכים מכניסים את השני הערכים כנ"ל מי שקורא לקונסטרקטור שמקבל את שלושת הפרמטרים האלה
קוראים לשניים והוא קורא לאחד וכו' אז זה גם פותר לנו את הבעיה בואו בשביל ההדגמה ניצור עוד אובייקט וניתן לו רק שני ערכים product name dvd שעולה 500 שוב פעם נציג את הקאונטר אנחנו רואים שיש לנו בכל מקום בדיוק את המספר הנכון של אובייקטים לאותו רגע.
עכשיו למרות שהכל עובד וטוב ויפה עדיין אנחנו פה עוד לא טיפלנו באחת הבעיות שטיפלנו בה בעבר שאומרת שהמחלקה צריכה להגן על הדאטה ממברס שיש לה על המידע שיש לה ולמעשה היא לא באמת מגנה כרגע על המשתנה של הקאונטר מפני שבכל מקום מתכנת ב' יכול לכתוב את הדבר הבא מכל סיבה שהיא product.counter=-70 למה הוא עושה את זה?
אין לנו מושג אבל הוא יכול לעשות את זה ומי שכתב את המחלקה היה צריך לדאוג לכך שהמתכנת ב' לא הצליח להכניס מידע שגוי בקאונטר למעשה מתכנת ב' לא אמור בכלל לגעת בקאונטר הוא אמור רק לקרוא מה שיש בו ולא לכתוב אליו אם אנחנו מריצים את זה אנחנו כמובן רואים שיש לנו פה מידע שגוי בתוך הקאונטר כי מתכנת בית הרס לנו אותו אז איך אנחנו עושים את זה
פה אנחנו צריכים להיזכר בטריק שלמדנו עם הפרופרטיז מה שאנחנו צריכים לעשות זה להפוך קודם כל את המשתנה קאונטר לפרייבט זה אומר שמבחוץ אין גישה ישירה אליו לאחר מכן נשים שיא קטנה ואנחנו רואים שיש לנו משתנה פרייבט עם שיא קטנה לאחר מכן אנחנו הולכים לאזור של הפרופרטיז ובונים פרופרטי מיוחד עבור הקאונטר
אבל הפרופרטי הזה הולך להיות read-only הרשת הגישה שלו כמובן היא public טיפוס נתונים integer השם שלו counter עם שיא גדולה ויש בו רק אזור get שמחזיר את הקאונטר עם שיא קטנה וזה אומר שמבחוץ כל מה שצריך לעשות זה לקרוא לפרופרטי קאונטר עם שיא גדולה.
שימו לב שאני עדיין לא רואה אותו מהסיבה שגם הפרופרטי הזה חייב להיות סטטיק. אז בואו נחזור לפה ונקרא לקאונטר בצורה כזאת בכל מקום שאנחנו רוצים לגשת אליו.
וכעת אם אותו מתכנת יחליט ללכת ולשנות לנו את הקאונטר הוא יחטוף שגיאת קומפילציה ולא יצליח לעשות את זה בכלל כאשר אנחנו רואים את השגיאה פרופרטי קאונטר קנוט בי אסיין טו it is read only.
יצרנו את הבעיה על ידי פרופרטי שגם הוא חייב להיות סטטיק. אם כך משתנים סטטיים זה משתנים שמוגדרים בתוך קלאס עם המילה השמורה סטטיק וכל מה שהם אומרים זה שהמשתנה עצמו לא שייך לאף אובייקט עתידי מהמחלקה, אף אובייקט מהמחלקה בעצם, אלא נפתחים באזור נפרד שנקרא סטטיק סגמנט פעם
אחת ויחידה. מתי אנחנו משתמשים במשתנה סטטי? כל פעם שאנחנו רוצים שיהיה לנו איזשהו משתנה מחלקה שיופיע פעם אחת עבור כל האובייקטים. אבל המילה סטטיק זה לא מילה שאנחנו יכולים להשתמש איתה רק במשתנים.
כלומר, ניתן להשתמש איתה גם בפונקציות. ואנחנו צריכים להבין למה לנו להשתמש עם המילה סטטיק בפונקציות. והסיבה לזה היא סיבה שהיא שונה לגמרי מהסיבה של שימוש במשתנים סטטיים.
לצורך ההדגמה של המילה static עבור פונקציות בואו נבנה פונקציה אחרת לגמרי בתוך מחלקה נפרדת לגמרי. נוסיף קלאס והקלאס הזאת לא קשורה בכלל לעולם של המוצרים כרגע והיא נקראת arrayOperations והתפקיד של המחלקה הזאת זה לבצע עבורנו חישובים של מערכים.
אז יש לנו פה את המחלקה, מה זאת אומרת חישובים של מערכים? זה אומר שיכול להיות לנו כל מיני מערכים חד-ממדיים בתוכנית ואנחנו רוצים לבצע עליהם כל מיני חישובים.
אז Object Oriented אומרת אם יש לכם כמה פעילויות כנראה שהן צריכות להיות בתוך מחלקה ייעודית משלהם. לכן כל החישובים המתמטיים על מערכים הולכים להיות בתוך מחלקה שמטפלת במערכים.
טוב, בואו נבנה פונקציה public int calculate sum נקבל איזשהו מערך ניקח כאן איזשהו משתנה שיסכום את ערכי המערך נרוץ בלולת for each על כל המערך, נסכום את כל הפריטים, ולבסוף נחזיר את הסכום.
בואו נבנה עוד פונקציה, התפקיד שלה זה להחזיר את ממוצע ערכי המערך. כאן אנחנו הולכים להחזיר דאבל, אם ממוצע יכול להיות נקודה עשורנית, וכל מה שאנחנו צריכים לעשות זה להחזיר את calculateSum ולחלק לאורך המערך.
כמובן שכדאי שנהפוך אחד מהם לדאבל, כדי שהתוצאה אכן תחזור כדאבל. ויש לנו פה את המחלקה הזאת. בואו נשים אותה פה בצד והיא מטפלת לנו בכל מה שקשור למערכים.
עכשיו אנחנו רוצים להשתמש בה. אנחנו עוברים להיות מתכנת ב' ומתכנת ב' מעוניין להשתמש במחלקה הזאת. אז מתכנת ב' יוצר איזשהו מערך ריגג'רי ואנחנו רוצים לחשב את הסכום או את הממוצע של ערכי המערך.
טוב, מה אנחנו צריכים לעשות בשביל לקרוא לפונקציות הללו? הפונקציות הללו כמובן נכתבו בתוך מחלקה ייעודית כך שנוכל מכל מקום להשתמש בהן.
לכן אנחנו צריכים ליצור אובייקט מהמחלקה דרך האובייקט לקרוא לפונקציות כמו שתמיד היינו עושים אז יש לנו פה את array operations my operations שווה new array operations וכל מה שאנחנו צריכים לעשות זה להדפיס את הסכום לדוגמה שיהיה my operations נקודה calculate sum והנה המערך בואו נציג גם את הממוצע בואו נריץ ונראה האם זה עובד כמו שצריך ואנחנו רואים שאכן אנחנו רואים את
תחום ואכן אנחנו רואים את הממוצע והכל נראה סבבה לגמרי ועכשיו אני רוצה שתסתכלו רגע על כל הקוד הזה ותגידו לי האם יש פה משהו שהוא לא כל כך הגיוני או לא כל כך אלגנטי ואם גיליתם מה זה הדבר הזה אז כנראה שהבנתם שהאובייקט הזה שיצרנו מהמחלקה הוא די חסר משמעות למה יצרנו את האובייקט הזה הרי אופריישנס מהמחלקה הרי אופריישנס שמקודם בנינו
אז אתם יכולים להגיד כמובן שהיית צריך ליצור אובייקט כי יש לך פה פונקציות בתוך המחלקה ואתה רוצה לקרוא לפונקציות האלה מתוך המחלקה ולקרוא לפונקציה במחלקה אתה צריך אובייקט מהמחלקה בשביל לקרוא לפונקציות בדיוק כמו שכאשר הייתה לנו את הפונקציה פרים ששייכת למחלקה פרודק ואנחנו רצינו לקרוא לה היינו צריכים לגשת לפרסט פרודקט ורק אחר כך היינו יכולים לגשת
לפונקציה פרינט דרך אובייקט והמחלקה ואנחנו ראינו שפונקציה של מחלקה פועלת או קודם כל היא נקראת דרך אובייקט והמחלקה והיא פועלת על הדאטה ממברס של המחלקה ששייכים לאותו אובייקט במקרה הזה פרסט פרודקט אז אם אנחנו בעצם רוצים לקרוא לפונקציות הנחמדות
האלה שכתבנו CalculateSum ו-CalculateAverage שנמצאות במחלקה ArrayOperations ברור שאנחנו צריכים ליצור אובייקט מ-ArrayOperations אבל אם אנחנו מסתכלים על זה אנחנו רואים שהסיבה לכך שיצרנו אובייקט היא בשביל לקרוא לפונקציות הללו אבל רגע מה בעצם קיים בתוך אובייקט אם אנחנו מסתכלים על האובייקט הזה Product
first product שווה new product מה יש בזיכרון שלו אז למעשה מה שיש בזיכרון של האובייקט הזה זה סך כל ה-data members שלו.
זאת אומרת בתוך כל אובייקט מסוג product יש שלושה משתנים product name, category name ו-price. אתם מוזמנים לחזור למצגת שהראתה מה זה class ומה זה object בשביל להיזכר מה קורה כאשר אנחנו פותחים אובייקט מהזיכרון, מה בדיוק נוצר לנו בזיכרון ומה מרכיב את האובייקט.