ההבדל בין ממשק למחלקה מופשטת ב- Java & C #
תוֹכֶן
שניהם ממשק ושיעור מופשט תורמים ל"סוג לא שלם "ב- OOP. לפעמים אנו זקוקים לסיווג-על כדי להגדיר "מה לעשות", אך לא "איך לעשות", איך לעשות חלק זה ייושם על ידי הכיתה הנגזרת בהתאם לצורך שלה, "ממשק"נותנים פיתרון לכך. לפעמים אנו זקוקים לשיעור סופר-קלאסי המגדיר איזה מבנה הכללי שיכול להיות מיושם על ידי כיתות נגזרות וכמה מבנים מוגדרים שיכולים לשמש את הכיתות הנגזרות, "שיעור מופשט"נותן פיתרון לכך. ההבדל המהותי בין ממשק למחלקה מופשטת הוא שהממשק אינו שלם לחלוטין, והמעמד המופשט אינו חלקי לחלוטין.
- טבלת השוואה
- הגדרה
- הבדלים עיקריים
- סיכום
טבלת השוואה
| בסיס להשוואה | ממשק | שיעור מופשט |
|---|---|---|
| בסיסי | כאשר יש לך רק את הידע בדרישות שלא לגבי יישומה, אתה משתמש ב"ממשק ". | כשאתה יודע חלקית על היישומים אתה משתמש ב"כיתות מופשטות ". |
| שיטות | הממשק מכיל רק שיטות מופשטות. | שיעור מופשט מכיל שיטות מופשטות כמו גם שיטות קונקרטיות. |
| גישה לשינוי שיטות | שיטות ממשק הן תמיד "ציבוריות" ו- "מופשטות", גם אם איננו מצהירים. מכאן שניתן לומר ככיתה מופשטת טהורה של 100%. | אין חובה ששיטה בכיתה מופשטת תהיה ציבורית ומופשטת. יכולות להיות לו גם שיטות קונקרטיות. |
| שינוי מוגבל לשיטות | לא ניתן להכריז על שיטת ממשק באמצעות השינויים הבאים: ציבורי: פרטי ומוגן תקציר: סופי, סטטי, מסונכרן, יליד, stringfp. | אין מגבלות על שינויים במשתנה הכיתה המופשט. |
| גישה לשינוי משתנים | שינוי Acess המותר למשתני ממשק הם ציבוריים, סטטיים וסופיים בין אם אנו מצהירים או לא. | המשתנים בכיתה מופשטת אינם צריכים להיות ציבוריים, סטטיים, סופיים. |
| שינויים מוגבלים עבור משתנים | לא ניתן להכריז על משתני ממשק כפרטיים, מוגנים, ארעיים ותנודתיים. | אין הגבלה על שינויים במשתנים קלאסיים מופשטים. |
| אתחול משתנים | יש לאתחל את משתני הממשק בעת הכרזתם. | אין חובה כי יש לאתחל משתני כיתה מופשטים בעת הכרזתם. |
| מופעי בלוקים סטטיים | בתוך הממשק, אתה לא יכול להכריז על מופע או חסום סטטי. | כיתה מופשטת מאפשרת מופע או חסום סטטי בתוכו. |
| בנאים | אינך יכול להכריז על בנאי בממשק. | אתה יכול להכריז על בנאי בתוך כיתה מופשטת. |
הגדרת הממשק
Java אינה מאפשרת ירושה מרובה. כלומר, כיתה יחידה לא יכולה לרשת יותר מכיתה אחת בכל פעם. ניתן להסביר את הסיבה שמאחורי זה. נניח שיש לנו שני כיתות הורים, A ו- B וכיתה נגזרת. המחלקה הנגזרת יורשת גם את הכיתות A וגם את B.כעת, לשניהם יש שיטת A ו- B מוגדרת שיטה (), אז זו תהיה שאלה עבור כיתה C איזו שיטת סט () של הכיתה עליה היא תירש. הפיתרון לבעיה זו הוא "ממשק".
access_specifier ממשק interface_name {return-type method-name1 (רשימת פרמטרים); return-type method-name2 (רשימת פרמטרים); הקלד final-varname1 = ערך; הקלד final-varname2 = ערך; // ... השיטה-סוג שיטה-שם N (רשימת פרמטרים); הקלד final-varnameN = ערך; }
מפרט הגישה מוכרז כציבורי מכיוון שהמחלקות צריכות ליישם את הממשק.
אין לנו את המושג "ממשק" ב- C ++. אבל, Java ו- C # מגדירים ממשק טוב מאוד.
ממשק בג'אווה:
- משתנים של ממשק הם כברירת מחדל תמיד ציבוריים, סטטיים וסופיים.
- יש לאתחל משתנים בזמן הכרזתם.
- לעולם לא ניתן להכריז על משתנים כפרטיים, מוגנים, ארעיים ותנודתיים.
- שיטות ממשק הן תמיד ציבוריות ומופשטות ואילו לעולם לא ניתן להכריז עליהן כפרטיות, מוגנות, סופיות, סטטיות, מסונכרנות, מקוריות וקפדניות.
- אינך יכול להכריז על כל ממשק בתוך הקונסטרוקטור כי המטרה העיקרית של הקבלן היא אתחול של משתני מחלקה, אך במשתני ממשק מאתחלים בעת הכרזתו.
- ממשק יכול לרשת ממשקים אחרים, אך המחלקה שמיישמת ממשק כזה חייבת ליישם את השיטות של כל הממשקים שעברו בירושה.
- כיתה יכולה לרשת יותר מממשק אחד בכל פעם, ועליו ליישם את כל השיטות של כל הממשקים שהתורשו.
הצורה הכללית של יישום ממשק ב- Java:
class class_name מיישם Interface_name {// class-body}
לצורך בירושה של ממשק, מחלקה משתמשת במילת מפתח "מיישמת", והמחלקה מיישמת את כל השיטות המוצהרות על ידי ממשק תורשתי.
ממשק ב- C #:
הממשק ב- C # דומה כמעט לממשק ב- Java למעט:
- הממשק ב- C # אינו מצהיר משתנים.
- שמו של הממשק מקודם עם בירה ראשונה והוא יורש עם סימן של המעי הגס (:).
הצורה הכללית של יישום ממשק ב- C #:
class class_name: interface_name {// class-body}
הגדרת שיעור מופשט
כיתה המכילה שיטה מופשטת אחת או יותר נקראת כיתת מופשט, וכיתה מוכרזת כמופשטת באמצעות מילת המפתח "מופשט", לפניה מילת המפתח "כיתה" בתחילת הצהרת הכיתה. מכיוון שהכיתה המופשטת מכילה את השיטה המופשטת שהיא מהווה לסוג לא שלם. מכאן שלא ניתן ליצור חפצים ממעמד מופשט. בכל פעם שכיתה יורשת מעמד מופשט, עליו ליישם את כל השיטות המופשטות של הכיתה המופשטת, אם לא, אז יש להכריז עליו גם כמופשטות. התכונה המופשטת עוברת בירושה עד להשגת היישום המלא של שיטות מופשטות.
הכיתה המופשטת יכולה להכיל גם שיטות קונקרטיות שיכולות לשמש את הכיתה הנגזרת כפי שהיא. אבל, אינך יכול להכריז על בנאי מופשט או על שיטה סטטית מופשטת בתוך כיתה מופשטת. הצורה הכללית של הכיתה המופשטת בג'אווה היא כדלקמן:
class class class_name {abstract method_name1 (); שיטה מופשטת שם 2 (); : return_type method_name3 (parameter_list) {// שיטת בטון} return_type method_name4 (parameter_list) {// שיטת בטון}};
הרעיון של מעמד מופשט דומה גם ב- Java וגם ב- C #. שיעור מופשט שונה מעט ב- C ++.
ב- C ++ אם בכיתה לפחות יש פונקציה וירטואלית אחת הכיתה הופכת לכיתה מופשטת. במקום מילת המפתח "מופשט", מילת המפתח "וירטואלית" משמשת להצהרת שיטה מופשטת.
- כאשר יש לך את הידע של "מה נדרש" אך לא של "איך זה יושם", יש להשתמש בממשק. מצד שני, אם אתה יודע מה דורש ויודע באופן חלקי כיצד הוא יושם, השתמש בכיתה מופשטת.
- ממשק כולל את כל השיטות שלו מופשטות, אך בכיתה מופשטת יש כמה שיטות מופשטות וכמה שיטות קונקרטיות.
- השיטות בממשק הינן ציבוריות ומופשטות ומכונה גם ככיתה מופשטת טהורה. מצד שני, השיטות בתוך תקציר אינן מוגבלות להיות ציבוריות ומופשטות בלבד.
- שיטת ממשק לעולם אינה יכולה להיות פרטית, מוגנת, סופית, סטטית, מסונכרנת, מקורית או stringfp. מצד שני, אין מגבלות לשיטות של מעמד מופשט.
- המשתנים בממשק הם ציבוריים וסופיים בין אם אנו מצהירים עליהם ובין אם לאו, בעוד שאין הגבלה כזו למשתנים של מעמד מופשט להיות ציבוריים וסופיים בלבד.
- משתנים בממשק לעולם אינם יכולים להיות ארעיים או תנודתיים מוגנים פרטיים ואילו אין הגבלה על משתנים בכיתה מופשטת.
- יש לאתחל את המשתנה של ממשק במהלך ההכרזה. מצד שני, ניתן לאתחל את המשתנים בכיתה מופשטת בכל עת.
- בתוך ממשק, לא ניתן להכריז על מופע או חסום סטטי, אך אתה יכול להכריז על מופע או חסימון סטטי בתוך כיתה מופשטת.
- אינך יכול להגדיר בנאי בתוך ממשק ואילו אתה יכול להגדיר בנאי בכיתה מופשטת.
סיכום:
כאשר אתה צריך ליצור מחלקת בסיס הכוללת צורה כללית של שיטות שיכולות להיות מיושמות על ידי הכיתות הנגזרות לפי הצורך שלהן, מושג הממשק והמעמד המופשט מסייע בכך.
