תכנות מונחה עצמים (OOP) - הורשה - הסתרת מתודות

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

הסתרת מתודות - Method Hiding
 
מאת: ארז קלר

הורדת דוגמאות קוד

עד כה נמנענו מלהכיל במחלקת הבסיס ובמחלקה הנגזרת מתודות בעלות חתימה זהה, מדוע?
נבחן את סדרת האיורים הבאה:
הסתרת מתודות - מחלקת הבסיס
במחלקה Base מוגדרת המתודה ()CalcAvg, המתודה מחשבת ומדפיסה את הממוצע של התכונות num1 ו-num2.
לדוגמה:
Base b = new Base(11,13);
b.CalcAvg();

בשלב הבא הוגדרה המחלקה Derived שיורשת את המחלקה Base:
הסתרת מתודות - Method Hiding - הורשה
המחלקה Derived מכירה ויכולה להשתמש במתודה ()CalcAvg שמוגדרת במחלקת הבסיס מכיוון שבהורשה המחלקה הנגזרת מקבלת את כל מה שמוגדר במחלקת הבסיס.
היא אמנם יכולה אולם זה בעייתי, ()CalcAvg מחשבת את הממוצע של שתי התכונות של מחלקת הבסיס, אולם כאשר המתודה מופעלת על ידי המחלקה הנגזרת היא אינה יודעת להביא בחשבון את התכונות המוגדרת בה.
דהיינו, אנו נתקלים בסיטואציה בה מתודה המתפקדת מצוין כאשר היא מופעלת על ידי מחלקת הבסיס בעייתית מאוד כאשר היא מופעלת על ידי המחלקה הנגזרת.
 
שפת #C מאפשרת לנו להסתיר מתודה אשר מוגדרת במחלקת הבסיס על ידי הגדרת מתודה בעלת חתימה זהה במחלקה הנגזרת תוך שימוש באופרטור new.
לדוגמה (MethodHiding01):
 
מחלקת בסיס Base:


 1  : class Base 
 2  : { 
 3  :     private int num1; 
 4  :     private int num2; 
 5  :     public Base(int num1, int num2) 
 6  :     { 
 7  :         this.num1 = num1; 
 8  :         this.num2 = num2; 
 9  :     } 
 10 :     public void CalcAvg() 
 11 :     { 
 12 :         Console.WriteLine((num1 + num2) / 2); 
 13 :     } 
 14 :     public int Num1 
 15 :     { 
 16 :         get 
 17 :         { 
 18 :             return this.num1; 
 19 :         } 
 20 :         set 
 21 :         { 
 22 :             this.num1 = value; 
 23 :         } 
 24 :     } 
 25 :     public int Num2 
 26 :     { 
 27 :         get 
 28 :         { 
 29 :             return this.num2; 
 30 :         } 
 31 :         set 
 32 :         { 
 33 :             this.num2 = value; 
 34 :         } 
 35 :     } 
 36 : } 
בשורה 10 מוגדרת המתודה ()CalcAvg אשר מחשבת את ממוצע שני הערכים הקיימים בתכונות המחלקה.

המחלקה הנגזרת Derived:


 1  : class Derived : Base 
 2  : { 
 3  :     private int num3; 
 4  :     private int num4; 
 5  :     public Derived(int num1, int num2, int num3, int num4):base(num1, num2) 
 6  :     { 
 7  :         this.num3 = num3; 
 8  :         this.num4 = num4; 
 9  :     } 
 10 :     public new void CalcAvg() 
 11 :     { 
 12 :         Console.WriteLine((Num1 + Num2 + num3 + num4) / 4); 
 13 :     } 
 14 :     public int Num3 
 15 :     { 
 16 :         get 
 17 :         { 
 18 :             return this.num3; 
 19 :         } 
 20 :         set 
 21 :         { 
 22 :             this.num3 = value; 
 23 :         } 
 24 :     } 
 25 :     public int Num4 
 26 :     { 
 27 :         get 
 28 :         { 
 29 :             return this.num4; 
 30 :         } 
 31 :         set 
 32 :         { 
 33 :             this.num4 = value; 
 34 :         } 
 35 :     } 
 36 : } 
בשורה 10 מוגדרת המתודה Derived.CalcAvg, המתודה מוגדרת באמצעות האופרטור new ומסתירה את המתודה בעלת החתימה הזהה המוגדרת המחלקת הבסיס.

Main:
 1  : class Program 
 2  : { 
 3  :     static void Main(string[] args) 
 4  :     { 
 5  :         Derived d = new Derived(2, 4, 6, 8); 
 6  :         d.CalcAvg(); 
 7  :     } 
 8  : } 
פלט:
דוגמת פלט של MethodHiding

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




 



כל הזכויות שמורות למחבר ©