הורשה - Inheritance
Employee ומחלקת Customer מכילות את אותם שדות - שם פרטי ושם משפחה - ואת אותן פונקציות GetDetails ו-Print. כשהתוכנית גדלה, כל שינוי צריך להיעשות בכמה מקומות. הפתרון הוא להעביר את הדברים המשותפים למחלקת בסיס.Person מחזיקה את השם הפרטי, את שם המשפחה, את הבנאים ואת הפונקציות המשותפות. היא מייצגת אדם בכלל.class Employee : Person מוסיף נקודתיים ואחריהן את שם מחלקת הבסיס. עכשיו Employee מקבל את כל מה שיש ב-Person, ומוסיף רק את מה שחסר לו, כמו Salary.Customer : Person מקבל את אותם שדות, ומוסיף CreditCard ו-ValidTo.: base(firstName, lastName). כך לא כותבים שוב את אותו קוד.base.GetDetails() ו-base.Print() קוראים לגרסה של מחלקת הבסיס מתוך המחלקה הנגזרת.GetDetails ו-Print גם במחלקה הנגזרת, מופיעה אזהרה, כי אותו שם וחתימה כבר קיימים במחלקת הבסיס. הטיפול בזה ילמד בנושא הפולימורפיזם.פרקי ההרצאה: הורשה - Inheritance
תמלול ההרצאה: הורשה - Inheritance
הטקסט המלא של הדקות הראשונות בהרצאה «הורשה - Inheritance» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
באחד הסרטונים הראשונים אנחנו ראינו שבכדי ששפה תיחשב כ-object-oriented יש לה שלושה אבני בניין encapsulation שזה היכולת ליצור ישות סגורה על ידי המילה class inheritance היכולת להעביר את כל מה שיש בישות שאנחנו בונים כלומר בקלאס שאנחנו בונים לקלאס אחרת בלי כתיבת קוד חוזר ו-polymorphism זה היכולת של פונקציה לשנות את המימוש שלה
ממחלקת בסיס למחלקה יורשת. אנחנו בעצם עוברים עכשיו לאבן בניין השנייה של Object Oriented שזה בעצם ההורשה. למה בעצם חשוב לנו לדעת הורשה ולהשתמש בזה? מעבר לעובדה שזה מאוד מאוד שימושי ואתם כל הזמן רואים את הכלי הזה ב-Object Oriented, זה פשוט חוסך לנו המון קוד וזה תכנות יותר נכון.
אז אנחנו הולכים לראות הורשה קודם כל על ידי מטלה מסוימת שאנחנו הולכים לקבל. והמטלה אומרת כזה דבר. אנחנו אמורים ליצור תוכנית לניהול מפעל. מה יש לנו במפעל?
במפעל יש לנו לקוחות ויש לנו עובדים. לעובד יש סך הכל שם פרטי, שם משפחה ומשכורת שכרגע יש לו. ללקוח יש סך הכל שם פרטי, שם משפחה, מספר כרטיס אשראי ותוקף כרטיס אשראי.
הדברים שקיימים ללקוחות ולעובדים. מה שאנחנו צריכים לעשות בתוכנית זה ליצור אובייקט עבור עובד אחד ואובייקט עבור לקוח אחד, לקלוט ערכים אליהם ולהציג את הפרטים על המסך.
זה כל מה שאנחנו אמורים לעשות. אז בואו קודם כל נלך ונבנה את המטלה הזאת כאילו שאין לנו מושג בכלל בהורשה, אנחנו לא יודעים הורשה ואנחנו לא הולכים להשתמש בזה.
לאחר מכן נעשה איזושהי אדפטציה ונכניס את הכלי שלו עכשיו ונראה מה זה עוזר לנו. אז דבר ראשון אנחנו צריכים לבנות עובד. אז בואו נצרף כרגע מחלקה שנקראת Employee. אמרנו שלעובד יש First Name, Last Name, בואו אפילו ניתן Private, Salary, Property, In, Get ו-Set, קונסטרקטור, Rack, קונסטרקטור שמקבל את שלושת הערכים ומהתחלת
ה-Data Member. האמת שסלארי אמור להיות דצימאל ויש לזה כספים.
מעולה. הדבר הבא שנבצע זה פונקציית הצגה. עכשיו מה שאנחנו רוצים לעשות זה להציג first name last name salary. פה סיימנו לבנות מחלקה אחת.
עכשיו אנחנו הולכים לבנות את המחלקה השנייה שמטפלת בקסטומר בלקוח. אז אנחנו הולכים להוסיף קלאס עבור קסטומר. לפני שנבנה את הקלאס קסטומר בואו נוסיף עוד משהו אחד לאמפלואי וזה בעצם הפונקציה של קבלת הפרטים שאנחנו צריכים להתעסק איתה עוד מעט.
Public void, get details, שמבקשת מהמשתמש enter first name, יש לנו פה קליטה של ה-first name, כנ"ל לגבי last name, וכנ"ל לגבי ה-salary.
בואו נעבור ונבנה את הלקוח. ושימו לב, תוך כדי זה שאני בונה את המחלקה customer, כמה דברים בעצם הם משוכפלים וכבר כתבנו אותם במחלקה אמפלואי אז בואו נשים את זה ורטיקלית נעלה את המחלקה האמפלואי פה למעלה ותוך כדי הבנייה שלי בקסטומר שימו לב מה בעצם חוזר על עצמו אז לקסטומר ראינו שיש first name ו last name אז אנחנו הולכים ליצור public string first name public string last name
לקסטומר אמרנו שאנחנו רוצים שיהיה לו מספר כרטיס אשראי public string credit card ואנחנו רוצים עוד איזשהו סטרינג לגבי התוקף של הכרטיס ואליד 2 נניח ינואר 2015 משהו כזה הכרטיס תקף שימו לב כבר יש לנו את הפרסטנד ואת הלסטנד שהם משוכפלים אבל מה לעשות זה מה שאנחנו צריכים בקסטומר ובאמפלוי לאחר מכן אנחנו רוצים קונסטרקטור ריק אנחנו רוצים קונסטרקטור
מלא שמקבל את כל הפרטים ושימו לב שהקונסטרקטורים למרות שהם נראים משוכפלים הם לא משוכפלים למה? מפני שהשם של הקונסטרקטור הזה זה Employee והשם של הקונסטרקטור הזה זה Customer.
אין פה שכפול בקונסטרקטורים. הקוד של הקונסטרקטורים אולי יכול להיות טיפה משוכפל, כי כאן אני רואה שיש לי first name שווה first name, last name שווה last name וזה דברים שחוזרים על עצמם.
first name שווה first name last name שווה last name יש לנו פה את ה-credit card ואת ה-valid to. סיימנו לבנות את הקונסטרקטורים, בואו נעבור ונבנה פונקציה של get details כאן אנחנו רוצים בעצם את אותו הקוד הזה שוב פעם אנחנו נתקלים בשכפול שני אלה בשביל לקלוט את הפרטים לאחר מכן אנחנו רוצים פחות או יותר את אותו הדבר עבור
קרדיט קארד ועבור ואליד דו בסדר לאחר מכן פונקציית הדפסה בואו נבנה אותה כאן אנחנו רוצים להדפיס שם פרטי שם משפחה עוד פעם שכפול ולאחר מכן להדפיס גם את הקרדיט קארד נמבר ולהדפיס גם את הוואליד 2. פה סיימנו לבנות אותם ואנחנו יכולים לבדוק את זה.
בואו נלך לפרוגרם, נבנה אובייקט אחד אמפלואי, אובייקט אחד קסטומר, נקלוט ערכים ונדפיס. אז יש לנו כאן את האמפלואי וקסטומר.
ובואו נבדוק. אנחנו מריצים, אנחנו רואים שאנחנו עכשיו הולכים לקבל נתונים לגבי האמפלואי. ומה שהוא אומר לנו זה Enter First Name ואני מכניס את מוישה, Last Name, וסלרי לאחר מכן אנחנו רואים את ההדפסה וכנראה עכשיו אנחנו מבקשים את הערך של הקסטומר
מקודם זה היה אמפלואי עכשיו זה קסטומר דנה לוי כרטיס אשראי ולאחר מכן ואלי 2 ינואר 15 והנה הפרטים הכל בסדר הכל עובד אבל הבעיה היא שהיו פה המון המון שכפולים עכשיו שתי המחלקות שבנינו הן מאוד מאוד פשוטות יש לנו פה לקוח ועובד מה היה קורה אם היינו צריכים גם ספק והיינו צריכים לקוח מועדף והיינו צריכים מזכירה ומנהל וטייס ודייל ונגר ואתם
מבינים את הרעיון שיכול להיות לנו המון מחלקות שכל המחלקות האלה מכילים דברים שהם משותפים כאשר אנחנו עובדים באובייקט אוריינטד אז מה שאנחנו עושים זה בעצם בניית מחלקות ומן סתם יכול להיות שהרבה מחלקות מכילות המון דברים משותפים.
אז בכדי למנוע את הצורך לחזור שוב ושוב ולכתוב כל פעם את הדברים המשותפים האלה מחדש יש לנו את הקונספט של הורשה. בואו נסתכל עכשיו מה זה בעצם הורשה.
אז הורשה אומרת כזה דבר אנחנו יכולים לבנות מחלקה שנחשבת מחלקת בסיס באנגלית זה נקרא בייס קלאס במקרה שלנו אנחנו רוצים לבנות מחלקה שמתארת אדם מפני שגם הלקוח וגם הספק שניהם אנחנו רוצים שיהיה להם שם פרטי ושם משפחה כי שני הדברים האלה הם משותפים ביניהם.
שני הדברים האלה צריכים להיות במחלקה שתחזיק את הדברים המשותפים בין הלקוחות לבין הספקים בין לקוח לספק למעשה ומה שמשותף זה שם פרטי ושם משפחה אז אם היינו חושבים על מה המחלקה שצריכה להחזיק שם פרטי ושם משפחה אז כמובן שהיא לא הייתה יכולה להיות רק לקוח או רק ספק כי היא הייתה צריכה להיות בן אדם כללי.
לאחר מכן אנחנו יכולים בבת אחת בלי לכתוב שום קוד חוזר לתת את כל המשתנים ואת כל הפונקציות כלומר את כל הדאטה ממברס ואת כל המתודות שקיימים בתוך המחלקה בתוך מחלקת הבסיס הזאת למחלקה אחרת שיורשת אותה.
כאשר אנחנו מבצעים את השירטוט הזה אז אנחנו עושים את זה עם חץ כלפי מעלה שימו לב חץ כלפי מטה זה תרשים זרימה חץ כלפי למעלה זה סימן בינלאומי להורשה.
זה אומר שהמחלקה שאנחנו כותבים למטה יורשת את המחלקה שאנחנו כותבים למעלה. וזה מתבצע בצורה כזאת. זאת אומרת שפרסון הולכת להיות מחלקה שתחזיק את הדברים שמשותפים לעובדים וללקוחות.
לאחר מכן אנחנו הולכים לבנות מחלקה של אמפלואי כמו שעשינו מקודם. אבל אנחנו לא הולכים לחזור על כל הקוד הזה שהיה משוכפל אלא פשוט לתת הוראה שכל הקוד שהיה בתוך המחלקה פרסון אנחנו גם אותו רוצים במחלקה שלנו.
בסרטוט זה מתבצע על ידי חץ למעלה שהולך מאמפלואי לפרסון, וזה אומר שאמפלואי יורשת את פרסון. המחלקה פרסון נחשבת מחלקת הבסיס, בייס קלאס, המחלקה אמפלואי נחשבת מחלקה יורשת, או לפעמים קוראים לזה מחלקה נגזרת, באנגלית זה נקרא Derived Class, Derived נגזר,
כי היא נגזרת מפרסון. אבל מה בקשר לקסטומר? אז כמובן שאנחנו יכולים לבצע פה כמה הורשות שאנחנו רוצים. זאת אומרת person היא מחלקת בסיס אחת אבל יכולות להיות המון מחלקות שיורשות אותה ומקבלות את מה שיש לה.
במקרה שלנו זה customer. מה שאתם רואים כרגע זה שרטוט שנקרא אץ הורשה באנגלית inheritance tree. זה בעצם שרטוט שמראה את הקשרים בין המחלקות השונות מבחינת ההורשה.
אילו מחלקות יושבות בבסיס, אילו מחלקות יורשות מהן. לדוגמה שלנו מספיק לנו person ו-employee ו-customer שיורשים את person.
אז איך אנחנו עכשיו הולכים ליישם את הדבר הזה מבחינת C-sharp? בואו נחזור בחזרה לתוכנית שלנו ונשים כאן בעצם עוד מחלקה, נכתוב עוד מחלקה שהיא תהווה את ה-person.
אחרי שנעשה את זה נראה איך אנחנו מבצעים הורשה ומה אפשר להיפטר ממנו. טוב, אז בואו נלך ל-Solution Explorer ונוסיף עוד קלאס זה נקראת person.
ומי מתארת לנו אדם כללי לגמרי? מה יש לאדם כללי? לאדם כללי יש first name, last name, יש לו איזשהו קונסטרקטור ריק, יש לו איזשהו קונסטרקטור שמקבל את כל המשתנים שמבחינתנו כרגע זה רק שם פרטי ושם משפחה, נכניס אותם ל-data members, יש לנו פונקציה לקבלת פרטים,
אבל הפרטים שאנחנו מקבלים הם כמובן רק שם פרטי ומשפחה, כי זה מה שיש ב-person. אנחנו יכולים פשוט לעשות קופי פייסט כרגע של get details הזאת כי זה בעצם אותו קוד.
אנחנו רוצים לומר למשתמש הכנסת שם פרטי ולקלוט הכנסת שם משפחה ולקלוט. לאחר מכן יש לנו פונקציה פשוטה של הצגת פרטים פה גם כן אנחנו יכולים להעתיק את מה שכתוב פה כי אנחנו רוצים להציג את השם הפרטי ואת השם המשפחה.
ופה סיימנו לכתוב את מחלקת הבסיס שזה מה שיש בה יש בה שם פרטי שם משפחה וזהו, והיא מתארת לנו בן אדם אחד כללי. טוב, אז בואו עכשיו נראה איך אנחנו יכולים לקחת את כל מה שיש בתוך המחלקה הזאת, ואני מזכיר לכם, בסך הכל משתנים ופונקציות, ולגרום להם להיות במחלקת ה-employee ובמחלקת ה-Customer מבלי לכתוב קוד חוזר.
כל מה שאנחנו צריכים לעשות כאשר אנחנו בונים את המחלקה ודרך אגב, במציאות אנחנו לא הולכים לבנות מחלקה שהיא נגזרת ורק אחר כך בונים את הבסיס.
את זה עשיתי בדוגמה הזאת רק בשביל להראות ולהדגיש את כל הקוד החוזר שהיינו צריכים לכתוב. במציאות אתם כמובן קודם כל הולכים לכתוב את person, ואז זה חוסך ממכם לכתוב את כל הקוד שאנחנו תכף הולכים למחוק.
אז במציאות אחרי שכתבנו את מחלקת הבסיס, במקרה הזה person, אנחנו הולכים ל-employee, וכל מה שאנחנו צריכים לעשות זה נקודותיים person ו that's it זהו זה סיימנו את ההורשה כעת employee יורשת את person ואנחנו צריכים להבין טוב טוב מה זה אומר זה אומר שבמחלקה employee יש עכשיו את כל מה שיש במחלקה person זה אומר שאנחנו לא צריכים לכתוב עוד פעם
first name ו last name למעשה זה לא יהיה הגיוני שנכתוב עוד פעם first name ו last name כי זה אומר שיש לנו עכשיו פעמיים first name ו last name אז אנחנו מוחקים את זה.
בואו נבצע את אותו הדבר במחלקה קסטומר, הנה היא פה, ונגרום לקסטומר לרשת את פרסון. זה אומר שאנחנו יכולים להיפטר מה-first name וה-last name, ב-first name, last name של קסטומר.
ועכשיו אנחנו יכולים לבדוק האם התוכנית עובדת. בואו נריץ, Enter first name, last name, salary, first name, last name, קרדיט קארט ווואליד והכל עובד פרפקט אבל רק רגע אני עבדתי פה ממש ממש קשה על המחלקה פרסון וכל מה שעשיתי זה חסכתי לכתוב את הפרסט ניים
ואת הלאסט ניים בקסטומר ואמפלואי לא הייתי אומר שזה מי יודע מה החיסכון של שורות קוד אז למעשה יש לנו פה כל מיני דברים נוספים שאנחנו יכולים לחסוך בכתיבת קוד לא רק את המשתנים ובנוסף יש עוד כל מיני יתרונות בהורשה הזאת שאנחנו כבר הולכים לראות.
הדבר הראשון שאנחנו הולכים לעשות זה לחסוך בעוד שורות קוד. כי בואו נסתכל קודם כל על get details. get details אומרת כזה דבר, כאשר אנחנו נמצאים במחלקה person אנחנו רוצים לקלוט מהמשתמש רק שם פרטי ושם משפחה.
כאשר אנחנו נמצאים במחלקה employee אנחנו רוצים לקלוט שם פרטי, משפחה ומשכורת אבל כבר אנחנו מזהים שיש פה ארבע שורות שחוזרות על עצמן ארבע שורות קוד שכבר עשינו במחלקה של פרסון עכשיו איך אנחנו יכולים לחסוך את הכתיבה שלהם ולקרוא לפונקציה הזאת getDetails שנמצאת במחלקה פרסון
דבר ראשון אנחנו רואים שהשם getDetails הוא אותו השם וזה לא סתם כאשר אנחנו בונים מחלקה ומשתמשים בקונספט של ההורשה וישנה איזושהי פונקציה שעושה פעולה מסוימת כמו קבלת פרטים אנחנו רוצים שהפונקציה הזאת תהיה גם בבסיס כי אנחנו רוצים לקבל פרטים בבסיס וגם בנגזרת אנחנו אף פעם לא נמציא שמות אחרים לפונקציות
כאלו. לדוגמה, אנחנו לא נקרא לפונקציה הזאת getPersonDetails ולפונקציה הזאת getEmployeeDetails. למה אנחנו אף פעם לא עושים את זה?
מפני שאז זה אומר שהמחלקה Employee מחזיקה שתי פונקציות לקבלת פרטים. בואו נסתכל עליהן ונראה ש-employee ברגע שאנחנו כותבים נקודה יש פה גם Get Person Details וגם Get Employee Details.
אנחנו לא רוצים לקלוט פעם רק את Person ופעם רק את Employee. אין שום משמעות להרבה פונקציות. ולכן אנחנו לא ממציאים שמות אחרים אלא אנחנו משתמשים באותו השם בדיוק.
כנ"ל כאשר אנחנו מבצעים את זה עבור פרינט. גם פרינט אנחנו לא כותבים פרינט פרסון במחלקת הבסיס פרסון ופרינט אמפלואי במחלקת אמפלואי ופרינט קסטומר ופרינט מנאג'ר וכולי.
הפונקציה מציגה פרטים על המסך והיא צריכה להיקרא פרינט. היא שייכת למחלקה מסוימת ולכן היא מדפיסה את הפרטים של המחלקה המסוימת. אוקיי, למה קיבלנו פה הערה?
והסיבה שקיבלנו פה הערה ולא שגיאה, אלא רק הערה מבחינת הקומפיילר, היא בגלל שיש לנו כבר פונקציה שנקראת print במחלקה employee ויש לנו כבר פונקציה שנקראת get details במחלקה employee ואנחנו כותבים עוד אחד.
אנחנו יודעים שלא ניתן לכתוב שתי פונקציות עם אותו השם ועם אותה החתימה בדיוק באותה מחלקה. מה זה אומר? נניח שהיינו פה בעולם האלגוריתמיקה תכנות פרוצדורלי והיינו רושמים דבר כזה public void do something וכאן אנחנו רושמים אחד על המסך.
אם עכשיו אנחנו לוקחים את הפונקציה הזאת, משכפלים אותה ופה עושים משהו אחר, מדפיסים שתיים על המסך, מריצים קומפילציה, אנחנו הולכים לחטוף על זה שגיאה.
מפני שאנחנו לא יכולים לכתוב שתי פונקציות עם אותה החתימה, אותו השם בדיוק, באותה המחלקה. אבל זה כאילו זה בדיוק מה שקיים לנו שמה.
בואו ניפטר משתי הפונקציות האלה. אם נסתכל על מה באמת קיים באמפלואי אנחנו נראה שבגלל שאמפלואי ירשה את פרסון אז אמפלואי קיבלה את כל מה שיש בפרסון זה אומר את הדאטה ממברס ואת הפונקציות זה אומר שלמחלקה אמפלואי בין אם כתבתי לה פונקציה שנקראת get details ובין אם לא כתבתי קיימת לה פונקציה שנקראת get
details. גם אם לא היינו כותבים פונקציית פרינט הייתה לנו פונקציית פרינט. בואו נראה את זה. אם אנחנו כרגע שמים בהערה את הפונקציות האלה ואנחנו חוזרים למיין אנחנו הולכים לראות שלאובייקט אמפלואי אכן קיימת פונקציה פרינט ואכן קיימת פונקציה getDetails.
גם אם אנחנו נמצאים בתוך המחלקה אמפלואי נניח באיזשהו קונסטרקטור אנחנו יכולים לראות שקיימת לנו פונקציה פרינט ואנחנו יכולים לראות שקיימת לנו פונקציה get details אפילו שהן לא באמת כתובות במחלקה עם פלואי כמו שקיים לנו first name אפילו שfirst
name לא כתוב במחלקה עם פלואי והסיבה לזה היא כי חוק ההורשה אומר אנחנו ירשנו את person זה אומר שקיבלנו את כל מה שיש בפרסון וכעת יש לנו את כל מה שיש בפרסון כאילו שכתבו את זה במחלקה שלנו אז בואו נחזור כרגע הסיטואציה שהתחלנו ונראה עכשיו שיש לנו פה שתי פונקציות get details ושתי פונקציות print וזאת בעצם ההערה שהמערכת אומרת לנו למה זה רק הערה ולא כמו מקודם שגיאה אנחנו
נראה בהמשך זו סיטואציה טיפה שונה מהסיטואציה שראינו מקודם כאשר הייתה שגיאה ואנחנו הולכים באמת לטפל בה בחלק השלישי של object oriented שנקרא פולימורפיזם אבל כעת נתעלם מההערה ורק נבין שיש למחלקה אמפלואי פונקציה שנקראת getDetails שנמצאת במחלקת הבסיס וקיבלנו אותה ועוד getDetails
שאנחנו כרגע כותבים במחלקה אמפלואי. אוקיי, אז כל מה שאנחנו צריכים לעשות זה פשוט לקרוא לפונקציה getDetails של המחלקה person מכאן במקום לכתוב את הקוד הזה בעצמנו.
בואו נמחק את הקוד והשאלה היא האם אנחנו יכולים פשוט לקרוא לגט. בצורה כזאת והתשובה היא לא מפני שאם אנחנו קוראים לגט דיטיילס בצורה כזאת זאת הגט דיטיילס שהיא תתבצע וזה מה שנקרא רקורסיה ראינו את זה במודול הקודם אז אנחנו לא באמת הצלחנו בצורה כזאת לקרוא לגט דיטיילס שקיימת במחלקת הבסיס שלנו אם הייתה לנו גט פרסון דיטיילס וגט
employee details אז כמובן שהיינו יכולים פה לרשום get person details לקרוא לה שהיא תקבל את הפרטים של first name ו last name כמובן שיש לנו אותה אנחנו יכולים לראות אותה כאן כי קיבלנו אותה ממחלקת הבסיס אבל כבר דיברנו על זה שאת זה לא עושים בשום אופן בואו נחזיר את זה מה כן עושים?
מה שעושים זה נזכרים ב-dis. Dis ראינו מדבר על האובייקט הנוכחי. dis.getDetails זאת הפונקציה ליתר דיוק הזאת כי היא נמצאת אצלי באובייקט הנוכחי אבל קיימת מילה מקבילה ל-dis והיא נקראת base.
בייס זה החבר של דיס והוא גם מתאר את האובייקט הנוכחי אבל הוא נותן לכם גישה ישירה לכל הפונקציות והדאטה ממברס שנמצאים באובייקט הנוכחי אבל שהגיעו מהבסיס שלנו.
וכאשר אנחנו אומרים בסיס אנחנו מדברים על מחלקה אחת למעלה. מי היא המחלקה האחת והיחידה מעלינו? וזה כמובן פרסון במקרה הזה מפני שאנחנו עם פלוי.
אז אם אנחנו חוזרים ואנחנו רושמים בייס נקודה אנחנו כמובן מקבלים את כל מה שיש לפרסון הנה הפרס ניים הנה הלאס ניים כמובן אנחנו רואים גם את גט דיטיילס וזה ההבדל למעשה בין דיס נקודה גט דיטיילס לבין בייס נקודה גט דיטיילס בייס תגיע ישירות לפונקציה שמעלינו אז בואו נרשום את גט דיטיילס בצורה כזאת אותו הדבר נבצע בפרינט.
במקום לחזור על הקוד של first name ו last name, בואו נמחוק ונרשום base.print זה אומר שהגענו למחלקת הבסיס לפרינט שלה.
אותו הדבר נבצע ב-customer. נלך ל-get details, נמחק את ארבעת השורות האלה. במקום לקלוט שם פרטי ושם משפחה, בואו ניגש ל-person שזה base.get details.
במקום עוד פעם להדפיס את first name ו-last name, ננחוק נרשום base.print בואו נחשוב האם אפשר לעשות משהו כזה גם בקונסטרקטורים בקונסטרקטור של אמפלואי אנחנו רואים שקיבלנו בקונסטרקטור המלא שם פרטי שם משפחה salary התחלנו את השם הפרטי ואת השם המשפחה שזה שתי שורות קוד זהות לקונסטרקטור הזה או ליתר דיוק של person לקונסטרקטור הזה אז כמו שהיה לנו רשימת
תתחול של קונסטרקטורים שבה יכלנו לקרוא מקונסטרקטור א' לקונסטרקטור ב' באותה המחלקה כאן אנחנו יכולים להשתמש בבייס בשביל לקרוא לקונסטרקטור של מחלקת הבסיס אנחנו רואים שהאינטליסנס מראה לנו שאנחנו פה קוראים לקונסטרקטור של פרסון ואכן לפרסון יש קונסטרקטור שמקבל first name ו last name גם פה הוא פשוט נרשום first name last name
וזה חוסך את שתי השורות האלה בואו ניקח את הקוד הזה