תוכן העניינים
מהי ירושה ב-C#
ב-C# באמצעות ירושה, מחלקה אחת יכולה לקחת או לרשת את המאפיינים והשיטות של מחלקה אחרת. במילים אחרות, הוא מאפשר יצירת מחלקה חדשה המבוססת על מחלקה קיימת, המכונה מחלקה בסיס או מחלקה על. מחלקה שנוצרה לאחר לקיחת המאפיינים של מחלקה בסיס נקראת מחלקה נגזרת או תת מחלקה.
מחלקה נגזרת זו ב-C# לא רק לוקחת מאפיינים של מחלקת הבסיס אלא יכולה גם להוסיף תכונות ייחודיות משלה.
איך עובדת הירושה ב-C#
ב-C#, תורשה מושגת באמצעות שימוש במעי הגס (:) סֵמֶל. שם מחלקת הבסיס מוגדר אחרי הקולון, והוא מצוין על ידי המחלקה הנגזרת.
להלן התחביר ליצירת מחלקה נגזרת שלוקחת מאפיינים ממחלקת הבסיס:
class DerivedClass : BaseClass{
// חברי כיתה נגזרים
}
כאן בקוד הזה, DerivedClass הוא השם של המחלקה הנגזרת, ו BaseClass הוא השם של מחלקת הבסיס. ה : סמל מציין ש- DerivedClass יורש מ- BaseClass. החברים של DerivedClass יכולים לגשת לחברי BaseClass, בתנאי שהם אינם פרטיים.
סוגי ירושה ב-C#
C# תומך בארבעה סוגי ירושה: ירושה יחידה, מרובת רמות, היררכית ומורשה מרובה. בואו נסתכל על כל סוג.
ירושה בודדת
ירושה יחידה היא הסוג הנפוץ ביותר של ירושה, כאשר מחלקה נגזרת לוקחת או יורשת מאפיינים של מחלקה בסיס בודדת בלבד.
לדוגמה, הקוד הנתון מסביר את היררכיית המעמדות ומדגים מושגי ירושה.
באמצעות System ;באמצעות System ;
מכונית כיתה
{
פּוּמְבֵּי בָּטֵל הַתחָלָה ( )
{
לְנַחֵם. WriteLine ( 'מכונית התניעה' ) ;
}
}
מחלקה טסלה : אוטו
{
פּוּמְבֵּי בָּטֵל להאיץ ( )
{
לְנַחֵם. WriteLine ( 'טסלה מאיץ' ) ;
}
}
תוכנית הכיתה
{
סטָטִי בָּטֵל רָאשִׁי ( חוּט [ ] args )
{
Tesla myTesla = טסלה חדשה ( ) ;
myTesla. הַתחָלָה ( ) ; // פלט: מכונית התניעה
myTesla. להאיץ ( ) ; // פלט: טסלה מאיץ
}
}
בקוד לעיל, ה כיתת רכב היא מחלקת הבסיס ויש לה שיטה שנקראת הַתחָלָה() , שפשוט מדפיס את ההודעה מכונית התניעה לקונסולה.
ה שיעור טסלה נגזר ממחלקת מכוניות, והוא לוקח את כל המאפיינים של מחלקת מכוניות. מחלקת טסלה מוסיפה שיטה בשם להאיץ() , שמדפיס את ההודעה טסלה מאיץ לקונסולה.
ה רָאשִׁי() הפונקציה מגדירה מופע של מחלקת Tesla שנקראת myTesla וקורא לשיטות Start() ו-Accelerate() שלה.
ירושה רב-שכבתית
ירושה רב-רמות היא המקום שבו מחלקה נגזרת יורשת ממחלקה נגזרת אחרת, שבתורה יורשת ממחלקה בסיס.
לדוגמה, קוד C# הבא מדגים תורשה ועקיפה של מתודה בהיררכיית מחלקות.
באמצעות System ;כיתה חיה
{
פּוּמְבֵּי בָּטֵל לאכול ( )
{
לְנַחֵם. WriteLine ( 'אכילת בעלי חיים' ) ;
}
}
כיתה יונק : בעל חיים
{
פּוּמְבֵּי בָּטֵל לָרוּץ ( )
{
לְנַחֵם. WriteLine ( 'יונק רץ' ) ;
}
}
כלב בכיתה : יונק
{
פּוּמְבֵּי בָּטֵל לִנְבּוּחַ ( )
{
לְנַחֵם. WriteLine ( 'כלב נובח' ) ;
}
}
תוכנית הכיתה
{
סטָטִי בָּטֵל רָאשִׁי ( חוּט [ ] args )
{
Dog myDog = כלב חדש ( ) ;
הכלב שלי. לאכול ( ) ; // פלט: אכילת בעלי חיים
הכלב שלי. לָרוּץ ( ) ; // פלט: יונק פועל
הכלב שלי. לִנְבּוּחַ ( ) ; // פלט: כלב נובח
}
}
כאן כֶּלֶב הוא מחלקה נגזרת שיורשת מ יונק , שבתורו יורש מ בעל חיים . למחלקת הכלב יש גישה לכל המאפיינים, השיטות וההתנהגות של יונק וחיה, והיא יכולה גם להגדיר שיטה ייחודית משלה לִנְבּוּחַ() .
ה חוג בעלי חיים היא מחלקת הבסיס ויש לה שיטה שנקראת לאכול() , שפשוט מדפיס את ההודעה Animal eating לקונסולה.
ה כיתת יונקים נגזר מהמחלקה Animal ומוסיף שיטה בשם לָרוּץ() , שמדפיס את ההודעה יונק רץ לקונסולה.
ה חוג כלבים נגזרת ממחלקת יונקים ומוסיפה שיטה הנקראת לִנְבּוּחַ() , שמדפיס את ההודעה כלב נובח לקונסולה.
השיטה Main() יוצרת מופע של המחלקה Dog בשם הכלב שלי וקורא לשיטות Eat(), Run(), ו-Bark() שלה.
שימו לב שהשיטות Eat() ו-Run() אינן מוגדרות במחלקה Dog, אלא עוברות בירושה ממחלקות האב שלה בעל חיים ו יונק , בהתאמה. ה לִנְבּוּחַ() מתודה מוגדרת רק במחלקה Dog.
ירושה היררכית
בירושה היררכית, מספרים שונים של מחלקות נגזרות עוברים בירושה ממחלקת בסיס אחת בלבד. לדוגמה:
באמצעות System ;צורה בכיתה
{
פּוּמְבֵּי בָּטֵל לצייר ( )
{
לְנַחֵם. WriteLine ( 'ציור צורה' ) ;
}
}
מעגל כיתה : צוּרָה
{
פּוּמְבֵּי בָּטֵל למלא ( )
{
לְנַחֵם. WriteLine ( 'מילוי מעגל' ) ;
}
}
כיכר הכיתה : צוּרָה
{
פּוּמְבֵּי בָּטֵל צֶבַע ( )
{
לְנַחֵם. WriteLine ( 'ריבוע צביעה' ) ;
}
}
תוכנית הכיתה
{
סטָטִי בָּטֵל רָאשִׁי ( חוּט [ ] args )
{
מעגל את myCircle = מעגל חדש ( ) ;
myCircle. לצייר ( ) ; // פלט: ציור צורה
myCircle. למלא ( ) ; // פלט: עיגול מילוי
כיכר mySquare = ריבוע חדש ( ) ;
mySquare. לצייר ( ) ; // פלט: ציור צורה
mySquare. צֶבַע ( ) ; // פלט: ריבוע צביעה
}
}
בקוד שלמעלה, שניהם מעגל ו כיכר הם מחלקות נגזרות היורשים מ צוּרָה . יש להם גישה לשיטת Draw() המוגדרת ב-Shape והם יכולים גם להגדיר שיטות ייחודיות משלהם Fill() ו-Color().
כאן יצרנו אובייקט של הכיתה Circle בשם myCircle ואובייקט של ה כיכר כיתה בשם mySquare . לאחר מכן אנו מתקשרים ל- לצייר() שיטה, אשר עוברת בירושה ממחלקת Shape, בשני האובייקטים.
לאחר מכן, אנו קוראים ל- למלא() שיטה ב-myCircle, הספציפית למחלקה Circle, וה- צֶבַע() שיטה ב-mySquare, שהיא ספציפית למחלקה המרובעת.
הפלט יודפס למסוף כדלקמן:
ירושה מרובה
ירושה מרובה היא המקום שבו מחלקה נגזרת יורשת ממספר מחלקות בסיס. עם זאת, C# אינו תומך בירושה מרובה. כדי להשיג פונקציונליות דומה, C# משתמש ממשקים .
סיכום
ירושה ב-C# מאפשרת למחלקות לרשת התנהגות ופונקציונליות ממחלקות בסיס. באמצעות ירושה, אנו יכולים לעשות שימוש חוזר בקוד וליצור זרימה היררכית בתוך התוכנית. על ידי הבנת סוגי הירושה השונים, ניתן לכתוב קוד יעיל ומאורגן יותר שקל יותר לתחזק ולהרחיב.