< Return to Video

ירושת אובייקטים - Object Inheritance (Video Version)

  • 0:01 - 0:03
    חזרנו עם התוכנית שלנו שיוצרת ווינסטונים
  • 0:03 - 0:08
    אבל הוספתי טיפוס אובייקט חדש
    שנקרא Hopper (הופר).
  • 0:08 - 0:12
    אני מגדירה את הופר באותו אופן
    שהגדרתי את ווינסטון
  • 0:12 - 0:16
    התחלתי עם פונקציית בנאי, נתתי לו את אותם
    המאפיינים ואת המתודה draw
  • 0:16 - 0:20
    והמתודה talk, ואז הוספתי עוד מתודה שנקראת
  • 0:20 - 0:24
    hooray (הידד), כי הופר אוהב לחגוג,
    לעומת ווינסטון שלא אוהב את זה כלל.
  • 0:24 - 0:28
    בתחתית הפונקציה יצרתי שני אובייקטי הופר חדשים
  • 0:28 - 0:31
    שקראתי להם lilHopper ו- bigHopper
  • 0:31 - 0:35
    וציירתי אותם, וקראתי למתודה talk על אחד,
    ולמתודה hooray על האחר
  • 0:35 - 0:38
    זה די מגניב
  • 0:38 - 0:40
    אם נסתכל על הקוד הזה כאן למעלה
  • 0:40 - 0:42
    אולי תשימו לב לדבר מעניין.
  • 0:42 - 0:52
    הקוד עבור Hopper הוא מאוד דומה לקוד
    עבור Winston. בייחוד הסתכלו על הבנאי.
    זהו אותו קוד כמו הבנאי של ווינסטון.
  • 0:52 - 1:01
    וגם הפונקציה talk היא בדיוק אותו קוד כמו
    הפונקציה talk של ווינסטון.
  • 1:01 - 1:04
    ולשניהם יש פונקציית draw זהה
  • 1:04 - 1:08
    כך שיש הרבה דברים משותפים
    לשני טיפוסי האובייקטים האלו
  • 1:08 - 1:11
    וזה הגיוני, כי אתם מבינים ש-Hopper
    ו-Winston הם שני טיפוסי אובייקטים
  • 1:11 - 1:15
    דומים בעולם שלנו. אם תחשבו על העולם האמיתי
  • 1:15 - 1:20
    מחוץ למחשב, רוב טיפוסי האובייקטים חולקים
  • 1:20 - 1:21
    מאפיינים דומים עם טיפוסי אובייקטים אחרים.
  • 1:21 - 1:24
    כמו למשל בממלכת החי. כל החיות
  • 1:24 - 1:27
    דומות אחת לשניה בדרכים מסוימות.
    ויש לנו סוגים שונים של חיות
  • 1:27 - 1:32
    כמו למשל בני אדם.
    ולבני אדם יש דברים משותפים עם שאר עולם החי
  • 1:32 - 1:34
    אבל יש להם גם דברים שמשותפים
    רק עם בני אדם אחרים.
  • 1:34 - 1:36
    אז נוכל לומר
  • 1:36 - 1:39
    שחיה היא טיפוס של אובייקט שהטיפוס
    של בן אדם יורש ממנו פונקציונליות.
  • 1:39 - 1:47
    אנחנו לא מתחילים מאפס, אנו מוסיפים על
    הפונקציונליות שירשנו מהיותנו בעלי חיים.
  • 1:47 - 1:49
    למשל, כל בעלי החיים משמיעים קולות
  • 1:49 - 1:51
    אבל בני אדם משתמשים בשפה.
  • 1:51 - 1:55
    הרעיון הזה של ירושה
  • 1:55 - 1:57
    הוא מאוד שימושי גם בתכנות.
  • 1:57 - 2:00
    אנו יוצרים שרשרת של ירושת אובייקטים
    בקוד ה-Javascript שלנו.
  • 2:00 - 2:03
    כדי לעשות זאת תחשבו על
  • 2:03 - 2:04
    מה משותף לטיפוסי האובייקטים שלנו
  • 2:04 - 2:07
    נמציא לדבר המשותף שם
  • 2:07 - 2:09
    כי אנחנו הולכים ליצור טיפוס אובייקט חדש
  • 2:09 - 2:11
    שמייצג את אובייקט הבסיס.
  • 2:11 - 2:12
    הבה נקרא להם יצורים (creatures).
  • 2:12 - 2:14
    הם שניהם יצורים.
  • 2:14 - 2:18
    אז נאמר var Creature שווה..
    ואז נרצה לשים את פונקציית הבנאי שלנו
  • 2:18 - 2:22
    אז בואו פשוט נגנוב את זאת של Hopper
    כי היא זהה גם לזו של Winston.
  • 2:22 - 2:24
    אוקיי.
  • 2:24 - 2:27
    ואז, בואו נראה..
  • 2:27 - 2:28
    עכשיו אנחנו רוצים..
  • 2:28 - 2:30
    מה נרצה לעשות עכשיו?
  • 2:30 - 2:32
    אולי אנחנו רוצים להוסיף את הפונקציה
    של דיבור (talk)
  • 2:32 - 2:39
    אז גם עבור מתודת talk נגנוב את של Hopper.
    אבל כמובן נרצה שהיא תהיה חלק מהאב טיפוס
    של היצור (creature) במקום.
  • 2:39 - 2:42
    אוקיי, יפה.
  • 2:42 - 2:45
    אז עכשיו יש לנו את טיפוס האובייקט של יצור.
  • 2:45 - 2:48
    אבל אנחנו צריכים לספר ל-Hopper שהוא צריך
  • 2:48 - 2:51
    לבסס את הפונקציונליות שלו על זו של Creature
  • 2:51 - 2:51
    נעשה זאת על ידי כך שנרשום את השורה הבאה
  • 2:54 - 2:59
    נרשום Hopper.prototype
  • 2:59 - 3:02
    שווה ל-Object.create
  • 3:02 - 3:05
    Creature.prototype
  • 3:05 - 3:14
    מה שהשורה הזו עושה הוא לספר ל-Javascript
    שצריך לבסס את אב הטיפוס של Hopper,
    כלומר את כל הפונקציונליות של Hopper,
    על אב הטיפוס של Creature.
  • 3:14 - 3:22
    זה אומר שבכל פעם שהשפה תחפש פונקציה של
    הופר, היא מחפשת קודם באב טיפוס של הופר,
  • 3:22 - 3:26
    אבל אחר כך, אם היא לא תמצא את הפונקציה
    היא תחפש אותה באב טיפוס של Creature.
  • 3:26 - 3:29
    הרעיון הזה נקרא שרשרת אבות טיפוס
    (prototype chain)
  • 3:29 - 3:34
    עכשיו, ברגע שעשינו זאת, אנחנו יכולים למחוק
  • 3:34 - 3:36
    את המתודה talk מ-Hopper
  • 3:36 - 3:38
    כי היא כבר קיימת אצל Creature
  • 3:38 - 3:40
    שנמצא גבוה יותר בשרשרת אבות הטיפוס.
  • 3:40 - 3:43
    מוכנים?
  • 3:43 - 3:44
    זה עבד!
  • 3:44 - 3:47
    זה עובד, כי מצאנו את הפונקציה באב הטיפוס
    של Creature במקום.
  • 3:47 - 3:51
    ננסה למחוק את הפונקציה הזו גם אצל ווינסטון.
  • 3:51 - 3:58
    אוקיי, זה לא עבד - אין לאובייקט מתודת talk.
  • 3:58 - 4:01
    מדוע? ובכן, יש לנו את הבנאי של ווינסטון
  • 4:01 - 4:04
    ואת המתודה draw, ומחקנו את talk.
  • 4:04 - 4:08
    שימו לב ששכחנו לספר גם לאב הטיפוס של ווינסטון
  • 4:08 - 4:09
    שעליו להתבסס על אב הטיפוס של יצור.
  • 4:09 - 4:11
    אז אנחנו צריכים את השורה החשובה הזו.
  • 4:11 - 4:13
    Winston.prototype שווה
    ל- Object.create
  • 4:13 - 4:15
    ואז בסוגריים Creature.prototype
  • 4:15 - 4:19
    יפה!
  • 4:19 - 4:20
    שימו לב למשהו חשוב
  • 4:20 - 4:26
    שמתי את השורה הזו אחרי פונקציית הבנאי,
    אבל לפני שאני מוסיפה כל דבר אחר
  • 4:26 - 4:29
    לאב הטיפוס של ווינסטון.
    זה מה שבדרך כלל תרצו לעשות.
  • 4:29 - 4:29
    אתם רוצים
  • 4:29 - 4:31
    לספר לאובייקט מיד בהתחלה
  • 4:31 - 4:34
    שזהו אב הטיפוס הראשוני שעליו האב טיפוס
    הנוכחי יהיה מבוסס
  • 4:34 - 4:37
    אבל אחר כך אנו מוסיפים עוד דברים לאב-טיפוס הזה
  • 4:37 - 4:42
    כי יכול להיות משהו שהוא ייחודי
    ל-Winston או ייחודי ל-Hopper
  • 4:42 - 4:44
    שאין לאובייקטי Creature.
  • 4:44 - 4:45
    זה ממש מגניב שאתם יכולים להגדיר כאלו דברים.
  • 4:45 - 4:50
    אוקיי. אם תסתכלו על זה,
    עדיין יש לנו קצת קוד שחוזר על עצמו
  • 4:50 - 4:52
    הקוד של הבנאי.
  • 4:52 - 4:53
    נכון? יש לנו אותו שלוש פעמים.
  • 4:53 - 4:57
    האם אנחנו יכולים פשוט למחוק אותו?
  • 4:57 - 4:58
    בואו ננסה.
  • 4:58 - 5:04
    אוקיי.. לא נראה שזה עבד
  • 5:04 - 5:07
    כי Hopper הופיע בפינה השמאלית העליונה,
    כאילו הוא שכח את כל המאפיינים שלו
  • 5:07 - 5:15
    זה כיוון ששפת Javascript לא מניחה שאתם
    רוצים את אותו בנאי, גם אם אתם רוצים לבסס
    את האב-טיפוס עליו
  • 5:15 - 5:19
    כך שניתן להגדיר בנאי משלנו לאובייקטים האלו.
  • 5:19 - 5:24
    אבל יש גם דרך קלה לקרוא לבנאי של אובייקט אחר
  • 5:24 - 5:29
    נעשה זאת כך:
  • 5:29 - 5:35
    (Creature.call(this, nickname, age, x, y
  • 5:35 - 5:41
    ראיתם, זה עבד. מה שזה עושה
  • 5:41 - 5:44
    זה לקרוא לבנאי של Creature.
  • 5:44 - 5:50
    זה קורא לפונקציה הזו, וזה אומר לקוד לקרוא לבנאי
  • 5:50 - 5:54
    כאילו הוא נקרא ישירות בתוך אובייקט Hopper
  • 5:54 - 5:57
    וכאילו הוא נקרא עם הפרמטרים האלו
  • 5:57 - 5:59
    אלו הם הפרמטרים שאיתם קראו ל-Hopper.
  • 5:59 - 6:04
    וזה פשוט יבצע את הקוד הזה כאילו הוא היה כאן
    בתוך הבנאי של האובייקט.
  • 6:04 - 6:05
    זה בדיוק מה שאנחנו רוצים, וזה עבד.
  • 6:05 - 6:10
    אנחנו יכולים
  • 6:10 - 6:12
    להעתיק את השורה הזאת גם לתוך
  • 6:12 - 6:14
    הבנאי של Winston.
  • 6:14 - 6:17
    וזה עובד. יופי!
  • 6:17 - 6:25
    אוקיי. תראו את זה. איחדנו את כל המאפיינים
    המשותפים והפונקציונליות המשותפת לתוך
    אובייקט בסיס יחיד, Creature
  • 6:25 - 6:28
    ויצרנו שני טיפוסי אובייקטים שמרחיבים
    את אובייקט הבסיס.
  • 6:28 - 6:31
    הם יורשים פונקציונליות,
    אבל הם גם מוסיפים דברים משלהם.
  • 6:31 - 6:36
    ומה שנחמד זה שאנחנו יכולים לשנות את
    הפונקציונליות המשותפת במקום אחד.
  • 6:36 - 6:40
    למשל אם נרצה לשנות את הגיל כמו קודם,
    נוכל לרשום '+' "yrs old"
  • 6:40 - 6:44
    עכשיו לכולם רשום "yrs old" אחרי הגיל שלהם.
  • 6:44 - 6:50
    או שאנחנו יכולים לשנות את המתודה talk, שיהיה כתוב "SUP"
  • 6:50 - 6:57
    ועכשיו כל ה-Winstonים וה-Hopperים
    אומרים "SUP".
    עכשיו כשראיתם איך ליצור
    טיפוסי אובייקטים ואיך לרשת מטיפוסי אובייקטים
  • 6:57 - 7:01
    אתם יכולים להתחיל לחשוב על איך זה יכול להיות
    שימושי בציורים, באנימציות, בסימולציות ובמשחקים.
  • 7:01 - 7:05
    לדוגמה, אולי יש לכם משחק ויש בו הרבה סוגי דמויות
  • 7:05 - 7:08
    וכולן יכולות לרוץ אבל רק חלקן יכולות לקפוץ
  • 7:08 - 7:12
    זהו מקום מושלם בשביל כמה טיפוסי אובייקטים
    ושימוש בירושה.
  • 7:12 - 7:16
    אבל אני בטוחה שאתם יכולים לחשוב
    על עוד הרבה שימושים אחרים.
Title:
ירושת אובייקטים - Object Inheritance (Video Version)
Description:

זהו פשוט צילום מסך של שיעור הקוד האינטראקטיבי שלנו, שהוכן כדי להקל על הכנת כתוביות ותרגום. עדיף לצפות בשיעורים שלנו בכתובת:
https://www.khanacademy.org/cs/programming/

This is just a screen grab of our interactive coding talk-through, prepared to make captioning and translation easier. It is better to watch our talk-throughs here:
https://www.khanacademy.org/cs/programming/
more » « less
Video Language:
English
Duration:
07:17

Hebrew subtitles

Revisions

Our website uses cookies for analysis purposes.