יתרונות של תכנות מונחה עצמים
class. בתוך מחלקה יש רק משתנים (Data Members) ופונקציות (Methods). בדוגמה יש מחלקה Customer עם first name ו-last name, ופונקציות בשם Input ו-Display בלי להוסיף "customer" לשם, כי הן כבר שייכות לישות. הרכב הוא מחלקה נפרדת. היתרון: אפשר לכתוב כל מחלקה בקובץ משלה, להחליף את כולה כמו שמחליפים חלק בטלוויזיה, והישויות לא מפריעות זו לזו.Display של רכב מנהלים דורסת את Display של כלי רכב ומציגה מידע אחר.פרקי ההרצאה: יתרונות של תכנות מונחה עצמים
תמלול ההרצאה: יתרונות של תכנות מונחה עצמים
הטקסט המלא של הדקות הראשונות בהרצאה «יתרונות של תכנות מונחה עצמים» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
ראשית, אנחנו הולכים לראות למה בעצם כדאי לנו לתכנת באובג'קט אוריינטד, מה בעצם היה לפני התכנות באובג'קט אוריינטד, מה הייתה הבעיה עם התכנות לפני זה, ואיך אובג'קט אוריינטד פותר את הבעיה.
אז בואו נניח שאנחנו רוצים לכתוב תוכנית ממש פשוטה, שכל מה שהיא עושה היא מקבלת פרטים בנוגע ללקוח, בואו נניח שם פרטי ושם משפחה, ומציגה אותם על המסך, ובואו נניח שהיא גם צריכה לקבל פרטים בנוגע לכלי רכב, נניח דגם ויצרן, ומציגה אותם על המסך.
אז יש לנו פה קבלת פרטים של לקוח, הצגה, קבלת פרטים של רכב והצגה. לפני Object Oriented התכנות היה נחשב תכנות פרוצדורלי. תכנות פרוצדורלי, או procedural programming, בעצם אומר שאנחנו יכולים להגדיר משתנים ופונקציות.
זה מה שאנחנו יכולים להגדיר, וממש קשר בין המשתנים לבין הפונקציות, או בין פונקציות לפונקציות אחרות בתוכנית. זאת אומרת שאם היינו מתכנתים בתכנות פרוצדורלי, בואו נניח שפת C הישנה היא שפה פרוצדורלית, זה אומר שהיינו צריכים לבנות משתנים שייצגו בעצם את הלקוח שלנו, אז היינו את ה-first name
והיינו את ה-last name של הלקוח, והיינו יכולים ליצור עוד משתנים עבור כלי הרכב, לדוגמה היצרן והדגם של הרכב. לאחר מכן היינו צריכים ללכת ולבנות כל מיני פונקציות, לדוגמה input customer בשביל לקבל את הפרטים של הלקוח, display customer בשביל להציג את הפרטים של הלקוח, input car בשביל לקלוט את הנתונים של הרכב, וdisplay car בכדי
להציג את הנתונים של הרכב. אז מה בדיוק הבעיה עם הקונספט התכנותי הזה שבו היה לנו משתנים ופונקציות? אז יש פה כמה בעיות עם השיטה התכנותית הזאת. דבר ראשון, הפונקציות האלה שאנחנו כותבים אין ביניהם כל כך קשר וזיהוי לאישויות עצמן.
זאת אומרת, יש לנו כאן משתנים שקשורים ללקוח, זה השם הפרטי והשם משפחה. ויש לנו פונקציות שקשורות ללקוח, אבל מה הקשר ביניהם? אלו סתם פונקציות שנמצאות בתוכנית.
הן מברוקות לנו באיזשהו קובץ בסורס קוד שלנו, כלומר בקוד של התוכנית שלנו. אם בעתיד יש לנו איזשהו בג באחת הפונקציות, קצת יהיה לנו קשה ללכת ולטפל בבג הזה או לאתר אותו.
או אם אנחנו רוצים להחליף פונקציה, אז קצת קשה להוציא אותה ולהחליף אותה בפונקציה אחרת, לפני שיכול להיות שבהמון המון מקומות בתוכנית משתמשים עם הפונקציה הזאת בכל מיני קונטקסטים שונים, כל מיני קשרים שונים, ויכול להיות שאנחנו נערוס איזשהו הקשר אחר כאן לגבי הרכב, הדגם והיצרן.
יכול להיות שאנחנו רוצים את הפונקציות Input Car וDisplay Car שהם יהיו ספציפית בשביל מכונית, אבל בטעות משתמשים איתם גם בשביל דברים אחרים.
אז אין כל כך סדר בתוכנית, הכל זרוק, משתנים בצד אחד, פונקציות בצד אחר, קשה לאתר בדיוק את הדברים ששייכים לרכב, קשה לאתר בדיוק את הדברים ששייכים ללקוחות, ונניח אם אני רוצה להחליף דברים ששייכים ללקוח, אני יותר מדי מתערבב פה בתוכנית עם דברים אחרים.
אז למעשה גילו במשך הזמן שאם התוכנית שלכם הולכת ונהיית ממש ממש גדולה, מאוד מאוד קשה לתחזק קוד כזה, מאוד קשה לאתר בגים בו, מאוד קשה להחליף דברים או להוסיף דברים אחרים.
אם מי שכתב את הקוד הזה מתפטר ומגיע מישהו אחר במקומו, הוא מאבד את הידיים ואת הרגליים בכדי להבין מה בעצם קורה בתוכנית. אז מה החלופה לזה? אז יש לנו את ה-Object Oriented Programming שאומר משהו אחר לגמרי.
דבר ראשון, אנחנו צריכים לזהות את הישויות שמשתתפות בתוכנית. ומקודם דיברנו עליהם. דיברנו על לקוח ודיברנו על כלי רכב. כאשר אתם מזהים שיש לכם ישות, אתם קודם כל הולכים ובונים את הישות הזאת בעזרת מילה שמורה שנקראת קלאס.
קלאס מגדירה לנו ישות חדשה, לדוגמה במקרה הזה, קסטומר, לקוח. בתוך הקלאס יש רק שני דברים בגדול, משתנים ופונקציות. המשתנים של הקלאס נקראים Data Members, הפונקציות של הקלאס נקראות Methodot או Methods באנגלית.
אז בתוך הישות הסגורה הזאת שאנחנו הולכים לבנות שנקראת customer אנחנו בונים את המשתנה first name ואנחנו בונים את המשתנה last name המשתנים האלה לא זרוקים במיין כמו בתכנות פרוצדורלי שיכל להיות לא זרוקים בסתם פונקציה אחרת הם זרוקים בעטיפה כזאת שהעטיפה היא הישות לקוח
כי בעצם אפשר להגיד שללקוח יש שם פרטי וללקוח יש שם משפחה, ולכן שני החבר'ה האלה, שני המשתנים האלה נמצאים בתוך הישות Customer. בנוסף, יש לנו פונקציות, אבל הפעם אנחנו לא צריכים לקרוא לפונקציה Input Customer, מפני שהיא חלק מהישות Customer, ולכן אנחנו יכולים פשוט לקרוא לה Input.
פונקציה נוספת, דיספלי, אנחנו לא צריכים לקרוא לדיספלי קסטומר, אולי אמציא כל מיני שמות אחרים, כי היא שייכת לישות קסטומר, ולכן מספיק דיספלי, אנחנו יודעים לגמרי שזה שייך לקסטומר.
בנוגע לכלי רכב, כלי רכב זה ישות אחרת, ולכן תהיה לנו מחלקה אחרת, קלאס נפרדת לגמרי, ובקלאס הזאת יש כמובן משתנים, אז את היצרן ואת הדגם אנחנו יכולים להגדיר בתוך הקלאס קר, בנוסף יש שם פונקציות, input וdisplay במקום לקרוא לזה input card וdisplay card פשוט input וdisplay או print שם חלופי שיכול להיות לדיספלי
ולכן יש לנו עכשיו שתי אישויות למה התכנות הזה הוא הרבה יותר טוב מהתכנות הפרוצדורלית והסיבה היא מפני שכעת אם קיים לנו баг בנוגע ללקוח אז אנחנו כנראה יודעים לגשת בדיוק לקלאס שמתארת את הקסטומר שהדרך אגב נכתבת בקובץ משלה קובץ source code משלה ומבחינתן אנחנו פשוט יכולים להעיף את כל הקלאס הזאת ולכתוב אחת אחרת
זה ממש מודולרי אנחנו יכולים לקחת את החלק הזה בדיוק כמו שאתם הולכים לתקן איזה חלק בטלוויזיה שלוקחים את הטלוויזיה מפרקים אותה מוציאים את החלק המקולקל זורקים אותו ומחליפים אותו בחלק אחר והטלוויזיה פועלת כך אנחנו יכולים ללכת בדיוק לחלק המקולקן, נניח קסטומר יש שם הבג, למחוק את כל הקלאס ולכתוב אחת אחרת או לאתר בקלות את הבג שיש שם
אם אנחנו רוצים לתחזק את התוכנית או להוסיף עליה דברים חדשים ואישיות חדשות, אין שום בעיה, ישות אחת לא מפריע על ישות אחרת המשתנים של ישות והפונקציות של ישות שייכים ספציפית לגבי הישות הזאת וישות זה בעצם כל שם עצם, כל רעיון שקיים בתוכנית, כל תפקיד שקיים בתוכנית, אנחנו יכולים להציג אותו בעזרת ישות מפרדת שלא מופריעה ולא נכנסת
לאישויות אחרות והיא קשורה רק לעצמה ומייצגת את עצמה תכנות הרבה יותר מובנה, הרבה יותר קל לפיתוח וכאשר אתם מתכנתים פרויקטים מאוד מאוד גדולים אז מאוד קל להתמצא בהם כאשר הם מחולקים לאישויות אישויות אז זה בגדול התכנות של Object Oriented שפת Object Oriented כוללת בעצם שלושה מרכיבים שאנחנו דיברנו
כרגע רק על הראשון בין המרכיבים אז בואו נראה את שלושת המרכיבים שכל שפה שהיא נחשבת Object Oriented תומכת בהם אז המרכיבים של כל שפת Object Oriented הדבר הראשון נקרא Encapsulation או בעברית זה נקרא כימוס Encapsulation זה בעצם היכולת לבנות ישות סגורה בדיוק כמו שמקודם אנחנו הראינו איך אפשר לבנות ישות
שמתארת לקוח וישות אחרת בכלל שמתארת מכונית כאשר יש לנו את היכולת הזאת לבנות ישות סגורה שבעצם מה שיש בתוך הישות הסגורה זה משתנים ופונקציות ברגע שיש לנו את היכולת הזאת זה החלק הראשון ב-Object Oriented וזה נקרא Incapsulation היכולת השנייה בעצם נקראת Inheritance Inheritance או בעברית הורשה זה היכולת שלנו
לקחת ישות מסוימת ולהעביר את כל מה שיש בה לישות אחרת בלי לכתוב קוד חוזר, בלי לעשות copy-paste של דברים מה יש בתוך ישות? בתוך ישות אמרנו שיש מאפיינים ופעילויות, כלומר משתנים ופונקציות, אוקיי?