PracticU

עקרונות תכנות מונחה עצמים - Unity OOP

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

עקרונות תכנות מונחה עצמים - Unity OOP
השיעורים הבאים עוסקים בעקרונות תכנות מונחה עצמים (Object Oriented Programming), שבהם הדגש הוא על המידע ועל הפעולות שאפשר לבצע איתו. ב-Unity משתמשים בזה ברוב המקרים, גם כשלא יוצרים את הכלים האלה בעצמכם.
מחלקה ואובייקט
1. זיהוי אובייקטים: קודם בודקים אילו אובייקטים יש בפרויקט, איזה מידע צריך לשמור על כל אחד מהם, ואילו פעולות אפשר לעשות איתם.
2. דוגמה של לקוח: מחלקה בשם Client שומרת name, address ו-phone, ויש לה מתודה buy שמקבלת מוצר. מחלקה Product שומרת name ו-price, ויש לה מתודות כמו עדכון מלאי.
3. מחלקה כתבנית: class הוא סוג מידע, ומכל מחלקה אפשר לייצר כמה אובייקטים, כמו כמה לקוחות שונים.
תורשה
מחלקה כללית, כמו Animal עם name, color ו-move, יכולה להיות הורה של Cat ו-Dog. היורשים מקבלים את החברים שלה, כך שלא צריך לכתוב את אותו קוד פעמיים. תיקון ב-move בהורה משפיע על כל היורשים.
הכמסה (Encapsulation)
חבר שמוגדר כ-public נגיש מבחוץ, ו-private נגיש רק בתוך המחלקה. העיקרון השלישי, פולימורפיזם, לא נלמד בקורס הזה.
השיעורים האלה תיאורטיים יותר, ובפיתוח רגיל ביוניטי משתמשים בעיקר בדברים שכבר קיימים.
השיעור הבא בקורס: Static Class

פרקי ההרצאה: עקרונות תכנות מונחה עצמים - Unity OOP

  1. 00:00

    מהו תכנות מונחה עצמים (OOP)

  2. 00:43

    המיקוד בנתונים ולא בפעולות

  3. 01:45

    דוגמה: לקוחות, מוצרים ומתודת קנייה

  4. 03:23

    מחלקה (Class) ומופעים (Objects)

  5. 04:34

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

  6. 06:20

    ירושה: כלב וחתול יורשים מ-Animal

  7. 07:32

    יתרונות הירושה: פחות קוד ותיקון במקום אחד

  8. 08:12

    הסתרת מידע עם private ו-public

תמלול ההרצאה: עקרונות תכנות מונחה עצמים - Unity OOP

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

  1. 00:02

    בשיעורים הקרובים אנחנו נדבר קצת על מה זה Object Oriented Design/Object Oriented Programming. השיעורים האלה יהיו קצת יותר תיאורטיים מכיוון שאנחנו כשאנחנו נפתח את המשחק או בכלל כשאנחנו מפתחים ביוניטי ברמה בסיסית יותר זה דברים שאנחנו אמנם משתמשים בהם אבל לא מייצרים אותם בעצמנו אלא

  2. 00:30

    משתמשים בדברים שקיימים כבר. בשביל שנבין מה לעזאזל אנחנו כותבים חשוב לי שנכיר את הדברים האלה. אז ככה קודם כל מה זה Object Oriented Design זה בעצם design/אפיון זה סגנון של כתיבת קוד שהוא מתרכז יותר בנתונים שלי מאשר בפעולות שאני עושה איתה.

  3. 01:02

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

  4. 01:27

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

  5. 01:45

    יש לי יחידת מידע אחת הדוגמאות הקלאסיות יש לי עסק ויש לי בעצם לקוחות אז מה מה אני רוצה לשמור על כל לקוח אז אני רוצה שיהיה לי בעצם נקרא לזה client ומה שאני רוצה לשמור עליו זה name address במידה ואני רוצה לשלוח לו במייל פרסומות או את מה שהוא קנה יש לו phone ולמשל יהיה לו by וזו פונקציה מתודה שאותו לקוח יכול לעשות.

  6. 02:36

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

  7. 03:07

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

  8. 03:23

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

  9. 03:56

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

  10. 04:37

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

  11. 04:55

    עכשיו אני אייצר חדש, ובמקום Client אני אייצר פה כלב, Dog. אז יש לי קלאס שנקרא Dog, יש לו Name, יש לו Color, יש לו Move ויש לו Bark.

  12. 05:21

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

  13. 06:07

    תורשה אני יכול להגדיר קלאס כללי יותר שנקרא animal אותו animal יכיל לי name, color ו-move.

  14. 06:27

    הדברים היותר כלליים שקיימים לי נניח בכל החיות או בכל החיות שיש לי בפרויקט במשחק במה שזה לא יהיה ואז מה שאני יכול לעשות זה להגדיר שCat יורש מ-animal ושDog יורש מ-animal ואז בעצם בקובץ הקוד של קאט ובקובץ הקוד של דוג מה שאני יכול לעשות זה למחוק את אלה.

  15. 07:02

    אני מגדיר שדוג וקאט יורשים מאנימל ואני אעשה את זה באמצעות חיצים לא לבנים אלא שחורים ודוג ועכשיו לדוג ולקאט לשניהם יש גם name גם color גם move וגם את הפונקציות או המשתנים שרלוונטיים להם בלבד.

  16. 07:36

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

  17. 08:00

    אז פה אני מעביר את היישום של מוב לאנימל וחסכתי לי המון קוד והמון בעיות. וגם לוגית אני מבין cat זה סוג של animal dog זה סוג של animal עכשיו נקודה אחרונה שרלוונטית למה שכבר דיברנו וזה הנושא של encapsulation כל הנושא הזה של private וpublic.

לקורס המלא: קורס פיתוח משחקים ביוניטי

ההרצאה הקודמת: פונקציה - Function

ההרצאה הבאה: Static Class

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

  • תכנות מונחה עצמים ב-NodeJS
  • יתרונות של תכנות מונחה עצמים
  • OOP
  • אובייקטים ומחלקות CLASS - תכנות מונחה עצמים בשפת Dart

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

  • קורס יסודות התכנות - שפת C# .NET - קורס תכנות למתחילים - דוט-נט / סי-שארפ - חומר לימוד של מדעי המחשב