בנאי המחלקה Constructor
public, ואין לו ערך מוחזר, גם לא void. הוא מקבל את הפרמטרים, למשל string productName.: this(productName, price), ובכך לחסוך שורות קוד חוזרות. במצב דיבאג רואים את הקפיצה בין הבנאים.ctor ואחריו Tab פעמיים יוצר שלד של בנאי. מחלקה מתארגנת לאזורים בעזרת #region: data members, constructors, properties ומתודות.פרקי ההרצאה: בנאי המחלקה Constructor
תמלול ההרצאה: בנאי המחלקה Constructor
הטקסט המלא של הדקות הראשונות בהרצאה «בנאי המחלקה Constructor» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
אנחנו ממשיכים ומגיעים לכלי הבא שמאפשר לנו Object Oriented בעולם האינקפסוליישן, כלומר בעולם בניית המחלקה. ובכדי להבין מה זה הכלי הזה ולמה אנחנו צריכים אותו, בואו נסתכל רגע על הקוד שעצרנו בו.
אנחנו רואים שבנינו כאן איזשהו אובייקט, ומיד הכנסנו ערכים לתוך ה-Data Members של האובייקט. מי שכמובן מבצע את הקוד הזה זה מתכנת ב', זה שמשתמש במחלקה.
מתכנת א' בנה את המחלקה, מתכנת ב' משתמש בה. אוקיי, עכשיו במקרה הזה אנחנו רואים שמתכנת ב' שרוצה לבנות אובייקט מוצר יש לו כבר מראש את הערכים השונים שהוא רוצה להכניס למוצר והדבר הזה קורה הרבה, קורה הרבה שאני יודע בדיוק מה הערכים שאני רוצה להכניס למוצר ואז אני רוצה לבנות
אובייקט ולהכניס את הערכים או לכל ישות אחרת. בואו ניקח ונראה דוגמה נוספת של מוצר נוסף ניקח בדיוק את הקוד הזה, משכפל אותו לפה, נקרא לו second product ונכניס לו כמובן ערכים אחרים, זה נניח 2.3, M זה 4.5, M, נדפיס את המוצר השני, נריץ, נראה שכל הנתונים מודפסים
כמו שצריך על המסך. עכשיו כאשר אנחנו בונים מחלקה אנחנו צריכים לבנות אותה בצורה כזאת שמתכנת ב' שהולך להשתמש בה יהיה לו כמה שיותר קל להשתמש עם המחלקה שאנחנו בונים כי הרבה פעמים גם כמובן זה אנחנו הולכים להשתמש עם המחלקה שאנחנו בונים ומה בדיוק הבעיה עם השימוש הזה?
אז למעשה אין פה באמת בעיה אבל אם אותו בחור יודע שהוא הולך להכניס בדיוק את הערכים האלה לאובייקט פרודקט אנחנו יכולים להקל עליו ולאפשר לקבל את הערכים האלה בדיוק בזמן יצירת האובייקט.
מה זאת אומרת בזמן יצירת האובייקט? אנחנו רואים שהשורה הזאת הראשונה זאת שורה שיוצרת אובייקט חדש ואנחנו ראינו את התחביר פרודקט שם של האובייקט במקרה הזה first product שווה new product יש פה פתיחת סוגריים כאילו שאנחנו קוראים לפונקציה וכל השורה הזאת זה בעצם השורה שיוצרת לנו
את האובייקט בזיכרון ובתוכו כמובן יש את הדאטה ממברס רק לאחר מכן הוא הולך ומכניס את הערכים לאובייקט במקרה הזה יש פה שלושה דאטה ממברס אבל יכול להיות במציאות שיש לי גם עשרה או חמש עשרה או ארבעה דאטה ממברס עכשיו מה זה בדיוק הסוגריים האלה הסוגריים האלה הם סוגריים מיוחדות לפונקציה מיוחדת
שזה בדיוק הכלי שאנחנו הולכים לראות כרגע שמתבצעת בדיוק כאשר נוצר אובייקט ואנחנו יכולים לבצע העמסה לפונקציה הזאת כך שהיא תקבל איזה פרמטרים שאנחנו רוצים שתפקידם יהיה להתחיל את האובייקט אז הפונקציה הזאת זו פונקציה מיוחדת שנקראת קונסטרקטור בעברית בנאי אם אנחנו עכשיו
רוצים להעמיס את הפונקציה הזאת אז אנחנו צריכים ללכת למחלקה עצמה ולכתוב כאן את הפונקציה אז לפני שנעשה את זה אנחנו הולכים פשוט לשנות כאן את כל הקוד הזה אז כרגע אני אשים את כל הקוד הזה בהערה מפני שתכף אנחנו בעצם משנים אותו.
אני חוזר בחזרה ואני רוצה לבנות את אותה פונקציה מיוחדת שנקראת קונסטרקטור. אז איך בונים קונסטרקטור? קודם כל גם לקונסטרקטור יש הרשאת גישה.
אם אנחנו רוצים שמבחוץ יצליחו לקרוא לה, זה יהיה public. לקונסטרקטור אין ערך מוחזר, זאת לא פונקציה רגילה ולכן אנחנו לא רושמים אפילו לא void. שם הקונסטרקטור ב-C-Sharp זה תמיד שם המחלקה, אנחנו לא יכולים לבחור שם אחר.
שם המחלקה זה Product ולכן גם הקונסטרקטור יהיה Product. לאחר מכן אנחנו מקבלים בדיוק את הפרמטרים שאנחנו רוצים לקבל מבחוץ. עכשיו אנחנו צריכים לזכור, אי אפשר לקרוא לקונסטרקטור בשום דרך אחרת מלבד יצירת האובייקט, כלומר קונסטרקטור מתבצע רק כאשר מתכנת ב' יוצר
אובייקט מהמחלקה, ולכן הקונסטרקטור מיועד לקבל משתנים שתפקידם לאתחל את האובייקט. אז מן הסתם אנחנו רוצים לקבל את שלושת הערכים של הדאטה ממברס.
לכן בואו נרשום כאן String Product Name, String Category Name ו-Decimal Price. מה על הקונסטרקטור לבצע? על הקונסטרקטור להכניס את הערכים שהוא קיבל ישירות ל-Data Members, אבל אם כמובן ערך צריך לעבור דרך איזשהו פרופרטי אני כמובן לא רוצה להכניס אותו ישירות לדאטה ממבר
אלא אני רוצה לעבור דרך הפרופרטי. בואו נסתכל רגע. אנחנו באחד הסרטונים האחרונים ביצענו פרופרטי עבור הפרודקט ניים הזה.
אנחנו רואים את הפרופרטי כאן. אז בכדי שיהיה פשוט בואו כרגע נוריד את הפרופרטי הזה. נישאר פה עם פרודקט ניים בעוד גדולה.
יש לנו כאן פרופרטי עבור הפרייס בלבד ואנחנו מעוניינים לגשת ולהכניס את הערכים לדאטה ממברס ומקסימום לעבור בתוך פרופרטי אם קיים פרופרטי.
אז קודם כל מה שאנחנו רוצים לעשות זה לגשת לדאטה ממברס שנקרא product name עם פי גדולה ולהכניס אליו את המשתנה שקיבלנו product name עם פי קטנה. מאוד מקובל שהשמות האלה יהיו ממש זהים, לא נהוג בתכנות לרשום לדוגמה pn עבור product name, אף אחד אחר כך לא מבין מה זה או p-name או כל מיני המצאות כאלה נהוג שהשמות יהיו כמה שיותר ברורים וממש זהים לשמות של ה-data
members כמובן עם אותיות שונות מבחינת k-sensitive category name שזה ה-data member כי זה עם c גדולה הולך לקבל את category name עם c קטנה שזה המשתנה שנשלח לקונספקטור price עם p גדולה אז הפרופרטי הולך לקבל את פרייס עם שיא קטנה שזה המשתנה הזה שנשלח לקונסטרקטור וכך גם אם מתכנת ב' שולח לקונסטרקטור מחיר המחיר עובר דרך הפרופרטי
ואז מתבצעת בדיקה לגביו וגם כאן אנחנו בעצם מגנים מפני מידע שיכול להיות שגוי שמישהו שולח על ידי הקונסטרקטור ופה סיימנו לבנות את הקונסטרקטור בואו נסדר טיפה את המחלקה זה הקונסטרקטור זה פרופרטי, יכול להיות לנו אחד או יותר פרופרטיז במקרה הזה יש לנו אחד, שתי הפונקציות האלה סתר וגתר אנחנו לא צריכים,
בואו נוריד אותם, כאן אנחנו רואים שאנחנו צריכים לגשת לדאטה ממבר product name עם פי גדולה, את הפונקציה הזאת אנחנו לא צריכים, הנה עוד פרופרטי ולכן אנחנו נעלה אותו לאזור של הפרופרטיז, זה יהיה read only property וכאן פשוט נגדיר שמפה והלאה כל הפרופרטיז נמצאים, כל המתודות, פונקציות של המחלקה הנמצאות פה.
מתאדס. אוקיי, אז יש לנו פה את המחלקה והיא מסודרת כמו שצריך. בדרך כלל נהוג לסדר קודם כל data members למעלה, לאחר מכן או constructors או properties, יש כאלה שאוהבים לסדר constructors ויש כאלה שאוהבים לסדר properties.
עוד מעט אנחנו נראה למה אנחנו אולי רוצים עוד constructors. אם סידרנו constructors אז לאחר מכן properties, ומתודות מתבצעות בסוף, בסוף כמובן שאין חשיבות לסדר אתם יכולים לסדר את זה בכל סדר שאתם רוצים אבל זה בעצם סדר הגיוני שהרבה אוהבים לסדר
אותם את המחלקה טוב אז אחרי שסידרנו את הקונסטרקטור אנחנו רוצים לגשת ולקרוא לקונסטרקטור בוא נשים את המחלקה סייד ביי סייד פה את הסלושן אקספלורר נסגור נחזור בחזרה ואנחנו רוצים לבנות אובייקט אז יש לנו פה את התחביר פרודקט פרסט פרודקט שווה ניו פרודקט
ואנחנו רואים עכשיו שכאשר אנחנו פותחים סוגריים אז דוטנט אומרת לנו כן אני יודעת שאתם כרגע קוראים לקונסטרקטור והקונסטרקטור באמת מקבל שם מוצר, שם קטגוריה ומחיר אז אנחנו כבר כאן יכולים לשלוח את שלושת הערכים שמקודם ידענו שיש לנו אותם עבור האובייקט הזה
אפל, פרוץ ו-2.3M ושימו לב שחסכנו שלוש שורות קוד במקרה הזה אם אין לנו עשרה data members והיינו יודעים את כולם היינו חוסכים 10 שורות קוד.
אז בעצם הרבה יותר קל למי שמשתמש במחלקה לעבוד עם קונסטרקטור כאשר יש לו מראש את הערכים שהוא רוצה לספק עבור האובייקט.
לאחר מכן בואו נדפיס אותם first product print וניצור לעצמנו עוד מוצר. זה יהיה second product קודם זה היה 4.5 מכל זה אפשר להיפטר. הקוד כרגע הרבה הרבה יותר מצומצם עבור מתכנת ב' בואו נריץ ואנחנו רואים שכל הערכים מוצגים על המסך.
אם אנחנו כרגע נריץ את זה עם דיבאגר, בואו נשים פה breakpoint, נריץ עם F5, נעצור בדיוק בשורה של ביצוע הקונסטרקטור וניכנס עם F11. אנחנו הולכים לראות שמתבצעת קפיצה ישירות לתוך הקונסטרקטור.
מה הערכים שהתקבלו לקונסטרקטור? אנחנו יכולים לראות את ה-Product Name שנשלח, Apple, את ה-Categoria, Fruits, ואת ה-מחיר, במקרה הזה 2.3. התפקיד של הקונסטרקטור זה להתחיל את משתנה המחלקה ולכן הוא הולך ועבור האובייקט הנוכחי שהוא כמובן first product
הוא מכניס את הערכים לdata members פה נכנס הproduct name לאחר מכן הcategory name ולבסוף הפרייס עובר דרך הפרופרטי בכדי לגלות האם הוא אכן חוקי או לא אנחנו רואים כרגע שהvalue הוא כמובן ה2.3 זה חוקי והוא נכנס לתוך הדאטה ממבר פרייס עם פי קטנה.
בסיום הקונסטרקטור אנחנו ממשיכים וכאן אנחנו יכולים לראות שהמחשב מדפיס לנו את הערכים על המסך. עכשיו מקודם אמרתי שמי שכותב את המחלקה צריך לכתוב אותה בצורה כזאת שמי שמשתמש בה יהיה לו הכי קל בעולם להשתמש בה והכי פשוט לעשות את זה על ידי חשיבה שאוקיי אנחנו הולכים להשתמש במחלקה הזאת בעוד כמה דקות ואיך יהיה לנו הכי נוח להשתמש בה אז יכול להיות
שאנחנו מסתכלים על המחלקה פרודקט ואנחנו אומרים בפרויקט הספציפי הזה שאנחנו בונים קורה הרבה שירצו לבנות מוצר ולמוצר יש מיידית שם מוצר כמובן הגיוני ויש מיידית מחיר אבל הוא לא באמת שייך לקטגוריה מסוימת או שהקטגוריה תינתן בהמשך או ויכול להיות מצב שאנחנו רוצים שמישהו יגדיר אובייקט בעצם עם המחלקה שלנו על ידי זה שהוא ייתן לנו מיידית רק את השם
של המוצר ואת המחיר בלי הקטגוריה יכול להיות שמצב כזה לא קיים ואנחנו לא צריכים להתעסק עם זה אבל אם המצב הזה כן קיים ואנחנו רוצים שקונסטרקטור יקבל רק חלק מהData Members כי הם בדרך כלל הData Members החשובים או הנפוצים או לפי דעתנו יש אותם על ההתחלה
אנחנו יכולים לבצע מה שנקרא העמסת קונסטרקטורים ולכתוב עוד פעם את הקונסטרקטור אבל הוא שמקבל רק את מה שאנחנו חושבים שמישהו הולך לספק לדוגמה Product Name וPrice בלבד אין לנו Category Name בואו נמחק את זה מפה וכעת זה מצב שיש לנו שני קונסטרקטורים אחד אחד שמקבל שלושה ערכים, אחד שמקבל שניים.
כל קונסטרקטור כמובן יש לו הרשאת גישה, אין לו ערך מוחזר והשמות שלהם הם תמיד השמות של המחלקה. טוב, אז בואו נסתכל איך בעצם מישהו יכול להשתמש בקונסטרקטור הזה.
אז אם מתכנת רוצה לבנות את האובייקט השני בוא נניח, והוא לא יודע כרגע מה הקטגוריה, אז הוא יכול פשוט להשתמש עם הקונסטרקטור ואנחנו רואים שיש פה שתי העמסות.
המסה הראשונה מקבלת רק שני ערכים המסה השנייה מקבלת שלושה ערכים. זאת אומרת שהיה אפשר גם להשתמש ביצירת האובייקט בצורה כזאת.
אנחנו יכולים ליצור אובייקט ולשלוח רק שם מוצר ומחיר בלבד בפני שאפשרנו לקונסטרקטור לקבל רק את הערכים האלה. בואו נוריד פה את הברייק פוינט, נריץ ונראה שאכן המוצר הראשון קיבל שלושה ערכים, אפשר לראות את זה פה, והמוצר השני קיבל רק שניים בננה וארבע וחצי.
Category name זה בעצם העמסת קונסטרקטור עכשיו האם יכול להיות מצב שמתכנת ב' שמשתמש במחלקה שלנו רוצה לבנות אובייקט אין לו את הערכים לשליחה לקונסטרקטור אם הוא פותח סוגריים שזה בעצם הקונסטרקטור הוא רואה שהוא יכול לשלוח שני ערכים ושלושה ערכים והוא לא רוצה והוא רוצה לפתוח אובייקט בצורה כזאת ולאחר
מכן לקבל מהמשתמש או לקלוט מקובץ או להשיג מכל מקור אחר את הנתונים ולבוא ולהכניס את הנתונים בעצמו לערכים product name אמור להיות public אוקיי אז פתאום אנחנו רואים שיש לנו כאן איזושהי בעיה ויש פה שקיעת קומפילציה ואם אנחנו עומדים עליה אנחנו רואים שהמערכת אומרת לנו product does not not contain a constructor that takes zero arguments כלומר אין לכם קונסטרקטור שמקבל
אפס פרמטרים אבל רגע, משהו לא ברור לי אם לא היה לנו פה בכלל קונסטרקטורים כלומר בהתחלה בכלל לא בנינו קונסטרקטורים אז לא הייתה בעיה לעשות את השורה הזאת זאת אומרת אם אני עכשיו מוריד לגמרי את כל הקונסטרקטורים שבנינו אנחנו פתאום רואים משהו מוזר אנחנו רואים שכמובן ששתי השורות
האלה לא עוברות קומפילציה מפני שאין לנו קונסטרקטורים כאלה אבל עכשיו השורה הזאת כן עוברת קומפילציה אז מה בדיוק קורה פה? אז מה שקורה זה איזשהו כלל מסוים שאנחנו צריכים להבין שקיים בהמון שפות Object Oriented והכלל אומר דבר כזה אם אתם בונים מחלקה ולא בניתם אף קונסטרקטור אוטומטית המערכת יוצרת עבורכם קונסטרקטור
שלא מקבל שום דבר בכדי שמתכנת ב' יוכל ליצור אובייקט בצורה כזאת מהמחלקה שלכם הקונסטרקטור הזה נקרא default constructor הוא לא עושה בעצם כלום והוא לא מקבל שום פרמטרים אבל פה ממשיך הכלל ואומר אם אתם בניתם קונסטרקטור