PracticU

פרויקט מעשי ב-#C - תוכנת צייר - חלק 28

בלי כתוביותעם כתוביות
PracticU › פרויקט מעשי ב-#C - תוכנת צייר › פרויקט מעשי ב-#C - תוכנת צייר - חלק 28
מילון מושגים:
מחלקה - תבנית בתכנות מונחה עצמים שמגדירה אילו נתונים ופעולות יהיו לאובייקטים שנוצרים ממנה.
ירושה - מנגנון בתכנות מונחה עצמים שבו מחלקה יורשת תכונות ופעולות ממחלקת אב, ויכולה להרחיב אותן.
בנאי - מתודה מיוחדת שמופעלת אוטומטית בעת יצירת אובייקט ממחלקה, ומאתחלת את ערכיו ההתחלתיים.
קומפיילר - תוכנה שממירה קוד מקור שנכתב בשפת תכנות לקוד שהמחשב יכול להריץ, ומדווחת על שגיאות תחביר.
פרמטר - ערך שמועבר לפונקציה או לפקודה כקלט, ומשפיע על אופן פעולתן ועל התוצאה שהן מחזירות.
אובייקט - יחידה בתכנות מונחה עצמים שמאגדת נתונים (תכונות) ופעולות (מתודות). נוצר בדרך כלל ממחלקה המשמשת כתבנית.
C# - שפת תכנות מונחית עצמים של מיקרוסופט, המשמשת בעיקר לפיתוח יישומים על פלטפורמת .NET.
פונקציה - קטע קוד בעל שם שמבצע משימה מוגדרת, מקבל ערכי קלט (פרמטרים) ויכול להחזיר תוצאה. מאפשרת לארגן קוד ולהשתמש בו שוב.

פרויקט מעשי ב-#C - תוכנת צייר - חלק 28
השיעור עוסק בהעברת השדה width מהמחלקות היורשות למחלקת הבסיס Shape, ובהשלכות של זה על ירושה ובנאים.
השלבים העיקריים
1. איחוד השדה במחלקת הבסיס: גם Line וגם FreeHand משתמשים באותו רוחב ועובי, ולכן השדה נשמר ב-Shape ולא בכל יורש בנפרד.
2. גישה מהיורש: השדה מוגדר internal, ולכן Line יכול לגשת אליו.
3. הבעיה עם read only: השדה מוגדר read only, ולכן אפשר לתת לו ערך רק בתוך הבנאי של Shape. בנאי של Line לא יכול לשנות אותו, והקומפיילר לא יאשר זאת.
4. קריאה לבנאי הבסיס: אחרי סוגר הפרמטרים של הבנאי כותבים נקודותיים ו-base(...). זו הדרך להפעיל את בנאי הבסיס. כשהבנאי של Shape רץ, הוא מאתחל את העובי לפני שהבנאי של היורש מסיים.
5. ירושה נגד כפילות: אם כל מחלקה תשמור את השדות המשותפים בעצמה, הקוד יתכפל. אחרי זמן זה קשה לתחזוקה, ושינוי של שדה אחד במקום אחד בלי שני במקום אחר יוצר תקלות.
איך זה עובד
היורש מכיל בתוכו את החלק של מחלקת הבסיס. כש-FreeHand נוצר, נוצר גם החלק של Shape בתוך אותו אובייקט. ב-C# אפשר לרשת ממחלקה אחת בלבד, והירושה נכתבת בנקודותיים אחרי שם המחלקה.
הבסיס המשותף נותן לכל הצורות מקום אחד לשדות ולפונקציות המשותפים.
השיעור הבא בקורס: פרויקט מעשי ב-#C - תוכנת צייר - חלק 29

פרקי ההרצאה: פרויקט מעשי ב-#C - תוכנת צייר - חלק 28

  1. 00:00

    הגדרת עובי כמשתנה מופע

  2. 02:12

    רוחב משותף ל-FreeHand וללין

  3. 02:51

    שמירת הרוחב במחלקת הבסיס Shape

  4. 04:14

    הכלה לעומת ירושה במחלקות

  5. 05:54

    גישה לשדה Internal מתוך היורש

  6. 07:26

    שדה Read-Only נקבע רק בבנאי

  7. 10:40

    קריאה לבנאי הבסיס עם base

תמלול ההרצאה: פרויקט מעשי ב-#C - תוכנת צייר - חלק 28

הטקסט המלא של הדקות הראשונות בהרצאה «פרויקט מעשי ב-#C - תוכנת צייר - חלק 28» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.

  1. 00:11

    יפה מאוד, אז בואו נריץ את זה, בואו נראה איזה רץ, ו-L וקליק ונלך לפה, יפה מאוד. אז הגענו לקונסטרקטור, קיבלנו את וויץ מסוג פלוט, ואז אני מבחינתי לא נכנס לזה, זה לא מעניין כרגע, ומה שאני הולך לעשות זה לתת ל-W את הערך, כרגע W הוא אפס, הוא משתנה גלובלי ברמת המחלקה, הוא משתנה מחלקה, מה שנקרא Instance Member,

  2. 00:43

    אינסטנטס וריאבל סליחה זה זה ממבר שהוא אינסטנטס וריאבל הוא חבר שהוא אינסטנטס וריאבל ממבר זה אומר שהוא חבר כמו במועדון ממברים של מועדון הוא ממבר ולא סתם שהוא ממבר הוא אינסטנטס וריאבל וריאבל אינסטנטס וריאבל זה אומר שהוא משתנה של כל אינסטנטס כל פעם שאני עושה a new new line אז יש לי אינסטנס חדש new

  3. 01:23

    מגדיר לי אינסטנס חדש אינסטנס זה תקריט וכל אינסטנס יש לו w משלו יש לו p1 משלו וp2 משלו וw משלו אנחנו בהזדמנות נלמד שאפשר להגדיר ממבר שהוא לא אינסטנס variable אלא שהוא class variable זה בהזדמנות אחרת אז אנחנו כרגע זה וזה אחד ואז אני בא ואומר בבקשה עכשיו w1 וזה בעצם מה שהקונסטרקטור רוצה, הקונסטרקטור מאתחה לי את השדה שזה יש קונסטרקטור.

  4. 02:06

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

  5. 02:26

    בעצם מה שאמרנו זה שיש הרבה דברים שהם משותפים לפרי-הנד ולליין. כל מה שמשותף לליין ולפרי-הנד, שמנו בשייפ. אחד מהדברים שמשותפים זה רוחב.

  6. 02:49

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

  7. 03:05

    וב-shape גם הגדרנו קונסטרקטור וב-shape גם אמרנו אוקיי אנחנו נקבל את wits float ונאחסן אותו ב-wits של shape אז ל-shape יש wits ואנחנו מאחסנים את ה-wits שקיבלנו בשדה ה-wits הזה יפה אז כשליין מקבל את wits הוא לא צריך לאחסן את ה-wits ב-wit משלו אין שום סיבה לזה כי כבר לבייס למחלקה שמייצגת את כל מה

  8. 03:51

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

  9. 04:19

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

  10. 04:39

    אני יורש את התכונות שלו, אבל אני לא מכיל אותו. אבל במידה מסוימת אני כן, אני לא מכיל, זאת אומרת, תקריות אינסטנסים של פרי-הנד לא מכילים אינסטנסים של שייפ.

  11. 04:57

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

  12. 05:30

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

  13. 05:44

    בואו נראה רגע את שייפ. או, אז וויץ הוא אינטרנל. זה אומר, האם זה אומר שפריהנד יכול לגשת לוויץ של שייפ?

  14. 06:05

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

  15. 06:18

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

  16. 06:45

    יפה, אז בעצם לליין כבר יש וויץ, עכשיו ליין יכול היה להגיד אוקיי וויץ מקבל את וויץ, הוא יכול היה להגיד את זה, שנייה אחת, יפה, תיאורטית באמת ליין מכיוון שהוא מכיל את בייס ולבייס יש וויץ אז גם ליין יכול לבוא ולהגיד הנה וויץ תקבל את וויץ, הבעיה עם זה זה שאמרנו בשייפ שהוויד שלו הוא read-only ומה עושה read-only read-only זה אומר אוקיי לא ניתן לשנות את זה כי כמו

  17. 07:33

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

  18. 07:57

    אז לא ניתן לשנות, אם לא ניתן לשנות את הרוחב, יפה. אז בזה שאמרנו שוויץ הוא read-only, אז בעצם אנחנו אומרים, מה זה בעצם אומר read-only? read-only אומר שרק בקונסטרקטור אני יכול לתת לו ערך.

  19. 08:23

    אם זה לא read-only, אז אני יכול לתת לו ערך איפה שבא לי, בכל פונקציה של המחלקה. אבל אם הוא read-only אז לא ניתן לשנות אותו זה הרי מה שבאתי להגיד אני בא להגיד לקומפיילר אנא ממך קומפיילר עזור לי שלא ישנו לי אותו אז הוא אומר בסדר אז תגיד לי שהוא read-only אז אני אומר לו ה-done compiler זה read-only אז הוא אומר בסדר אני לא אתן

  20. 08:51

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

  21. 09:29

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

  22. 10:01

    הוא יכול לקחת ממנו ערך, אבל זה לא יעבור. למה זה לא יעבור? למה זה לא יצליח? כי וויטס הוא read-only של שייפ. זה אומר שהוא זמין לשינויים רק בתוך הקונסטרקטור של שייפ.

  23. 10:19

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

  24. 10:55

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

  25. 11:29

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

  26. 11:48

    יפה, אז מה אני אומר פה? אני אומר פה אוקיי כשמהתחלים אותי כשמהתחלים אותי אז אני מהתחל את הבסיס שלי את שייפ שבתוכי

לקורס המלא: פרויקט מעשי ב‑#C אונליין

ההרצאה הקודמת: פרויקט מעשי ב-#C - תוכנת צייר - חלק 27

ההרצאה הבאה: פרויקט מעשי ב-#C - תוכנת צייר - חלק 29

הרצאות קשורות מקורסים אחרים

  • תרגיל 24 - תוכנת צ'אט - חלק 1
  • פרויקט מעשי ב-#C - ספר טלפונים - חלק 1
  • תרגיל מעשי Delegate Event
  • שדרוג צייר שלנו על canvas

קורסים נוספים במסלול

  • קורס WinForms - תוכנות רגילות בווינדוס
  • פרויקט מעשי ב-#C - בונים מחשבון פשוט
  • פרויקט מעשי ב-#C - ספר טלפונים
  • קורס ADO.NET - חיבור אתר למסד נתונים
  • קורס תכנות מתקדם - #Advanced .NET C
  • קורס WCF - תקשורת למתקדמים בדוט-נט