הסבר על this
this, שמתייחסת לאובייקט הנוכחי, ומדגים מתי משתמשים בה: כשיש התנגשות שמות בין פרמטר לבין data member, וכשרוצים להעביר את האובייקט הנוכחי לפונקציה אחרת.Point הפרמטר נקרא x, וגם ל-data member יש שם X. כשכותבים x = x, הערך מועתק לעצמו ולא נשמר בתכונה.this.X = x;. this מתייחס לאובייקט שהפעיל את הבנאי, כלומר לאובייקט שנוצר.p1 ו-p2 וקוראים ל-Print על p2, ה-this בתוך הפונקציה הוא p2, ולכן מוצגים הערכים שלו.Drawer מציירת נקודה על המסך, והפונקציה Print שולחת לה את this. כך האובייקט עצמו מועבר למקום אחר, בלי שהמחלקה השנייה צריכה לדעת את שם המשתנה בחוץ.this(...) בתוך בנאי קורא לבנאי אחר של אותה מחלקה.this, כי אין אובייקט שהפעיל אותה. בכל פונקציה לא סטטית אפשר לגשת לנתונים של האובייקט בעזרת this, אבל כשאין התנגשות שמות השימוש בו מיותר.this מאפשר לכתוב קוד ברור כשיש התנגשות שמות, ולהעביר את האובייקט הנוכחי למקום אחר בתוכנית.פרקי ההרצאה: הסבר על this
תמלול ההרצאה: הסבר על this
הטקסט המלא של הדקות הראשונות בהרצאה «הסבר על this» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
אנחנו עוברים לכלי נוסף שקיים ב-Object Oriented וזאת פשוט המילה השמורה Ds. אנחנו ראינו אותה כאשר אנחנו השתמשנו ברשימת אתחול בקונסטרקטורים אבל יש לה משמעות נוספת שכדאי לנו להכיר.
אז Ds זאת מילה מאוד מאוד חשובה שניתנת לשימוש בתוך פונקציות במחלקה ובואו נראה מה זה בדיוק אומר.
לצורך הדגמה מה שאני אעשה אני פתחתי פה פרויקט חדש ואני רוצה להוסיף מחלקה חדשה שכל התפקיד שלה זה לתאר ישות של נקודה.
כלומר, נניח שאנחנו מתעסקים באיזשהו פרויקט גרפי ואנחנו רוצים שיהיו לנו נקודות על המסך. אז כמובן נקודה ישות ואנחנו יכולים להגדיר מחלקה שמייצגת נקודה.
אז בואו נפתח מחלקה, נקרא לה point ונחשוב נקודה אחת מה היא בעצם מכילה. היא מכילה מיקום בממד שמיוצג על ידי x ועל ידי y. כמובן צריכה להיות לנו פה איזושהי פונקציה להצגת הפרטים של הנקודה.
בואו נציג את x ואת y ויש לנו כרגע מחלקה שמתארת לנו נקודה אחת. אם אנחנו רוצים להשתמש בה, בואו נחזור בחזרה למיין, כל מה שאנחנו צריכים לעשות זה להגדיר אובייק ממנה.
נניח זאת p1, p1 נקודה x שווה 10, p1 נקודה y שווה 20, p1 נקודה print ויש לנו את הנקודה מוצגת על המסך.
אוקיי, אבל מקודם אנחנו ראינו שבעצם אם יש לנו את הנתונים לפני זה, אולי כדאי שנאפשר למי שמשתמש במחלקה לשלוח את הנתונים האלה לקונסטרקטור. אז בואו נוסיף קונסטרקטור למחלקה פוינט.
דרך אגב, אנחנו יודעים שקונסטרקטור מתבצע על ידי public, point וכולי, אבל אנחנו יודעים שגם יש כל מיני קיצורי מקלדת שאנחנו יכולים לרשום ו.net משלימה אותנו.
הקיצורים האלה נקראים snippets. זה פשוט קוד שאנחנו יכולים לכתוב ללחוץ tab-tab במקלדת והסניפט נשתל. עבור קונסטרקטור קיים סניפט שנקרא ctor.
אנחנו רואים גם את האייקון של הסניפט וגם שכתוב לנו code snippet for constructor. אם אנחנו רושמים ctor tab-tab המערכת פשוט רושמת לנו את כל הקונסטרקטור, חוסך מאיתנו כמה שניות של כתיבה.
מה אנחנו רוצים לעשות בקונסטרקטור? אנחנו רוצים קונסטרקטור אחד ריק בכדי שניתן יהיה לפתוח אובייקט ריק, ואנחנו רוצים קונסטרקטור אחד שמקבל x, ו-Y. עכשיו אנחנו רוצים לקחת את המשתנים של הקונסטרקטור ולהכניס לדאטה ממבר.
האם הקוד שכרגע כתבתי הוא הגיוני? אנחנו כבר רואים שיש פה איזושהי בעיה מבחינת האדיטור. מבחינת ויז'ל סטודיו, היא אומרת לנו, יש פה משהו לא כל כך הגיוני.
ומה שלא הגיוני פה זה שאני השתמשתי כאן ב-X בעוד קטנה וב-Y כעוד קטנה, וגם כאן X קטנה, Y קטנה. עכשיו, כמובן שיכלתי לשנות, ואם המשתנה הזה הוא public אולי כדאי שהוא יהיה ב-X גדולה.
אבל לצורך הדוגמה באמת אני רוצה כרגע להישאר עם X קטנה ו-Y קטנה כאן. אז מה שקורה כאן זה שיש פה שם של משתנה שהינו data member באותו השם בדיוק כמו משתנה שהינו משתנה לוקאלי של פונקציה.
דבר ראשון השאלה היא אם מותר לעשות את זה והתשובה היא כן מותר לעשות את זה. אין שום בעיה שיהיה לנו משתנה לוקאלי בפונקציה בשם זהה לחלוטין גם מבחינת case sensitive למשתנה גלובלי שנפתח ברמת המחלקה והשאלה הנשאלת הבאה בתור ואם אני עכשיו רושם x לאיזה x אנחנו מתכוונים והתשובה היא שהמשתנה הלוקאלי הוא יותר חזק מפני שהוא יותר קרוב לקונטקסט
שבו אני נמצא לקוד ולהקשר שבו אני נמצא כרגע אז כאשר אנחנו כותבים x שווה x בשני המקרים התייחסנו לx הזה ומה שעשינו זה לקחנו את הערך שלו והכנסנו לעצמו וזה קצת לא הגיוני לביצוע ולכן המערכת אומרת לנו שיש לו פה משהו לא הגיוני ולא השפעתי על שום דבר.
בואו נסתכל על השגיאה assignment made to same variable did you meant to assign something else כלומר התבצע פה השמה לאותו המשתנה מאותו המשתנה לאותו המשתנה כלומר רק ה-X הזה וזה לא כל כך הגיוני.
אז אני בעצם רוצה עדיין להישאר פה עם X קטנה ועדיין להישאר פה עם X קטנה כנ"ל עם Y ולהצליח לעשות את הפעילות הזאת. כאן אנחנו מגיעים לשימוש במילה דיס ודיס כל מה שהוא מציין והאובייקט הנוכחי.
מה זה אומר האובייקט הנוכחי? האובייקט הנוכחי מציין אותו אובייקט שדרכו התבצעה הקריאה לפונקציה או לקונסטרקטור. עכשיו אנחנו מסתכלים כאן במיין ואנחנו רואים שמישהו כתב point p1 שווה new point וזה אומר שהוא יצר אובייקט אחד ויחיד הוא יצר אובייקט וקרא לו p1 הפעיל קונסטרקטור כאשר אנחנו בתוך הקונסטרקטור
הזה משתמשים עם המילה this אז בהקשר הזה בדיוק בהפעלת השורה הזאת דיס יהווה או יהיה בדיוק פי 1. זאת אומרת האובייקט פי 1 יהיה דיס או דיס יהיה האובייקט פי 1 בקריאה הזאתי אם מישהו ייצור אובייקט שני פוינט פי 2 שווה ניו פוינט כאן הקונסטרקטור יופעל שוב פעם עבור האובייקט
פי 2 אז דיס יהיה פי 2 במקרה השני. זאת אומרת דיס זאת מילה שניתנת לשימוש בתוך קונסטרקטור או פונקציה שמתארת את אותו אובייקט שהפעיל את הקונסטרקטור או את הפונקציה או את הפרופרטי או וואטאבר מה שאנחנו מתעסקים איתו.
אז אם אנחנו רושמים this נקודה בגלל שאנחנו באובייקט פוינט אנחנו מקבלים את ה-x ואת ה-y ולכן אם אנחנו רושמים this נקודה x אנחנו כמובן הולכים להגיע ל-data member x מפני שהוא שייך לאובייקט ו-this זה האובייקט.
אם אנחנו רושמים סתם ככה x אז ראינו של-x יש כוח יותר גדול ולכן זה המשתנה הלוקאלי. כלומר, למשתנה הלוקאלי יש כוח יותר גדול מהמשתנה הגלובלי ולכן x במקרה הזה זה המשתנה הלוקאלי.
וכך אנחנו בעצם הצלחנו לפתור את הבעיה על ידי כתיבת ds x שווה x, ds y שווה y. אז ds זה האובייקט הנוכחי. עכשיו, בתוך הפונקציה print אנחנו רואים שגם כאן הגשנו למשתנים הגלובליים האם גם כאן יכלנו להשתמש בדיס נקודה x ודיס נקודה y והתשובה היא כמובן שיכלנו לעשות את זה אבל במקרה הזה זה היה קצת מיותר מפני שכאשר אתם כותבים דיס נקודה x או סתם
x זה תמיד יהיה אותו הדבר אלא אם כן כבר יש לכם את השם x כמו שקיים כאן אז דיס מתאר את האובייקט הנוכחי אם אנחנו הולכים לרשום דיס נקודה x כמובן שזה אותו אובייקט שקרה לפונקציית פרינט. בואו נסתכל רגע איך זה מתבצע ניקח במקרה הראשון ב-p1 10 ו-20 ונציג אותו במקרה השני ניקח
30 ו-40 ונרשום p2 נקודה פרינט. נשים כאן ברייק פוינט נריץ נגיע לפוינט p1 ונסתכל שזה בעצם שם אובייקט שמכיל 10 ו-20 בתור x ו-y.
ניכנס עם f11 לתוך הפונקציה print ונראה בדיוק מה אומר this. this מתאר אובייקט point שיש לו 10 ו-20. בקיצור זה בדיוק האובייקט p1.
המחלקה point לא מכירה את השם p1 מפני שזהו שם עתידי שהולך להיפתח מבחינתה על ידי מתכנת ב' שהולך להשתמש במחלקה פוינט. ומי שכותב את המחלקה פוינט, מתכנת א', לא באמת יודע מה השם שמתכנת ב' הולך לתת לאובייקטים שהוא פותח, וזה גם לא אמור לעניין אותו.
אבל אותו השם פי אחת מוכר במחלקה פרוגרם במיין, וזה האובייקט מסוג פוינט. בתוך המחלקה פוינט השם הזה הוא בעצם דיס. דיס יהיה האובייקט הנוכחי שכרגע קרה לפונקציה הנוכחית שאנחנו נמצאים בה. אם אנחנו נמשיך את ההרצה של הדיבאגר אנחנו אמורים להגיע ליצירת אובייקט P2 וכאשר אנחנו מגיעים לפרינט אז כעת אם
אנחנו מסתכלים מה זה דיס, דיס בכלל זה אובייקט