תוֹכֶן

• טבלת השוואה
• הגדרה של ירושה:
• הגדרת פולימורפיזם
• סיכום:

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

1. טבלת השוואה
2. הגדרה
3. הבדלים עיקריים
4. סיכום

טבלת השוואה

בסיס להשוואה	ירושה	פולימורפיזם
בסיסי	ירושה היא יצירת מחלקה חדשה באמצעות המאפיינים של המחלקה שכבר קיימת.	פולימורפיזם הוא בעצם ממשק נפוץ לצורות מרובות.
יישום	הירושה מיושמת בעיקרון על שיעורים.	פולימורפיזם מיושם בעיקרון על פונקציות / שיטות.
להשתמש	לתמוך במושג השימוש חוזר ב- OOP ומקטין את אורך הקוד.	מאפשר לאובייקט להחליט לאיזו צורה של הפונקציה יש להפעיל מתי, בזמן קומפילציה (עומס יתר) וכן זמן ריצה (עקיפה).
טפסים	ירושה עשויה להיות ירושה יחידה, ירושה מרובה, ירושה רב-שכבתית, ירושה היררכית וירושה היברידית.	פולימורפיזם עשוי להיות פולימורפיזם לקבץ זמן (עומס יתר) או פולימורפיזם בזמן ריצה (עקיפה).
דוגמא	שולחן הכיתות יכול לרשת את התכונה של ריהוט הכיתה, שכן שולחן הוא רהיט.	שולחן הלימוד בכיתה יכול להיות גם עם פונקציה set_color (), וכיתת Dining_table יכולה להיות גם set_color של פונקציה () כך, איזו צורה של הפונקציה set_color () שתוכל להפעיל יכולה להיות מוחלטת בשניהם, לקמפל זמן וזמן ריצה.

הגדרה של ירושה:

ירושה היא אחת התכונות המכריעות ב- OOP, התומכות בתוקף "יכולת לשימוש חוזר". ניתן לתאר שימוש חוזר כיצירת מחלקה חדשה על ידי שימוש חוזר בתכונות של המחלקה הקיימת. בירושה יש מעמד בסיס, שיורש על ידי הכיתה הנגזרת. כאשר כיתה יורשת מעמד אחר, החברים / ות בכיתת הבסיס הופכים לחברים / ים של הכיתה הנגזרת.

הצורה הכללית של ירשת כיתה היא כדלקמן:

class-class-class-name: access-specificier base-class-name {// body of the class};

כאן, מפרט הגישה מספק את מצב הגישה (פרטי, ציבורי, מוגן) לחברים / ים בכיתת הבסיס לכיתה הנגזרת. אם אין מפרטי גישה, כברירת מחדל, הוא נחשב כ"פרטי ". ב- C ++, אם המחלקה הנגזרת היא "struct", אז ברירת המחדל של מפרטי הגישה היא "public".

ב- C ++ ניתן להשיג ירושה בחמש צורות. ניתן לסווג אותם כ: -

• ירושה יחידה (רק כיתת-על אחת בלבד)
• ירושה מרובה (מספר דרגות-על)
• ירושה היררכית (כיתת-על אחת, תת-קבוצות רבות)
• ירושה מרובה (נגזרת מכיתה נגזרת)

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

class class-derivated-name מרחיב את שם class-class {// body of the class};

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

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

// צורה ראשונה להתקשר לבנאי. class supper_class {supper_class (argument_list) {..} // constructor of super class}; sub_class בכיתה מרחיב את supper_class {sub_class (argument_list) {..} // הקבלן של sub_class super (argument_list); // sub_class קורא לבנאי של מחלקת העל}};

// שנייה עבור supper_class של super class {int i; } sub_class בכיתה מרחיב את supper_class {int i; sub_class (int a, int b) {super.i = a; // i של מחלקת העל i = b; // i של תת המשנה}};

הגדרת פולימורפיזם

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

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

עומס בכיתה {int a, b; ציבורי: עומס יתר (int x) {// בניית עומס יתר () קונסטרוקטור a = x; להחזיר א; } עומס יתר int (int x, int y) {// עומס יתר שני () קונסטרוקטור a = x; b = y; להחזיר a * b; }}; int main () {עומס יתר O1; עומס O1. (20); // עומס יתר ראשון () שיחת בנאי O1.overload (20,40); // עומס יתר שני () שיחת בנאי}

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

base class {public: virtual void funct () {// פונקציה וירטואלית של cout class class << "זהו פונקציות class base ()"; }}; class deriv1: public base {public: void funct () {// פונקציה וירטואלית של מחלקת הבסיס שהוגדרה מחדש ב class1 class cout << "זוהי פונקצית class1 deriv1 ()"; }}; int main () {base * p, b; נגזר 1 d1; * p = & b; p-> פונקציה (); // שיחה לפונקציות בכיתת הבסיס (). * p = & d1; להחזיר 0; }

1. ירושה היא יצירת מעמד שמקורו בתכונה שלו ממעמד שכבר קיים. מצד שני, פולימורפיזם הוא ממשק שניתן להגדירו במספר צורות.
2. ירושה מיושמת בשיעורים ואילו הפולימורפיזם מיושם בשיטות / פונקציות.
3. מכיוון שהירושה מאפשרת למעמד נגזר להשתמש באלמנטים ובשיטות שהוגדרו במחלקת הבסיס, הכיתה הנגזרת אינה צריכה להגדיר את אותם אלמנטים או להשתמש בשיטה כך שוב, אנו יכולים לומר שהיא מגדילה את השימוש חוזר בקוד ומכאן, מקטינה את אורך הקוד . מצד שני, הפולימורפיזם מאפשר לאובייקט להחליט באיזו צורה של השיטה הוא רוצה להפעיל בשני קומפילציה והן בזמן ריצה.
4. ניתן לסווג את הירושה כירושה יחידה, ירושה מרובה, ירושה רב-שכבתית, ירושה היררכית וירושה היברידית. מצד שני, הפולימורפיזם מסווג כעומס יתר ומגביל.

סיכום:

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