הבדל מפתח - ירושה לעומת ממשק ב-Java
Java היא שפת תכנות שפותחה על ידי Sun Microsystems. ניתן להשתמש ב-Java לפיתוח יישומים שונים. זוהי שפה מרובת פרדיגמות אשר תומכת מונחה עצמים, מובנית וכו'. היתרון העיקרי של Java הוא שהיא תומכת בתכנות מונחה עצמים (OOP). המתכנת יכול ליצור מחלקות ואובייקטים. ישנם ארבעה עמודים ב-OOP. הם תורשה, פולימורפיזם, הפשטה ואנקפסולציה. ירושה וממשקים קשורים ל-OOP. ההבדל העיקרי בין ירושה לממשק הוא שהירושה היא להפיק מחלקות חדשות ממחלקות קיימות וממשק הוא ליישם מחלקות מופשטות וירושה מרובה.
מהי ירושה ב-Java?
ירושה יכולה להשיג שימוש חוזר בקוד. ירושה עוזרת לעשות שימוש חוזר בתכונות ובשיטות של מחלקה קיימת. המנגנון של גזירת מחלקה חדשה באמצעות מחלקה ישנה נקרא ירושה. הכיתה הישנה ידועה בתור כיתת הורים או כיתת על. המחלקה הנגזרת נקראת כיתת ילד או תת-מחלקה.
התחביר של הירושה של Java הוא כדלקמן.
class subclass_name מרחיב את superclass_name {
הצהרת משתנה;
הצהרת method;
}
ניתן להסביר את מושג ההורשה באמצעות הדוגמה הבאה. נניח שיש מחלקה בשם A כדלקמן.
מחלקה ציבורית A{
public void sum(){
System.out.println(“Sum”);
}
}
אם ברצוננו להוסיף שיטה חדשה מבלי לשנות את המחלקה הקיימת, נוכל לעשות זאת באופן הבא.
מחלקה ציבורית B{
public void sub(){
System.out.println(“Sub”);
}
}
מתכנת יכול להשתמש בירושה כדי להשתמש בסכום A().
מחלקה ציבורית B מרחיבה את המחלקה A{
public void sub(){
System.out.println(“Sub”);
}
}
בפונקציה הראשית, אפשר ליצור אובייקט של B ולקרוא ל-sub(), ששייך למחלקה B ול-sum(), ששייך ל-class A באמצעות ירושה.
public static void main(String args){
B obj=new B();
obj.sub();
obj.sum();
}
ישנם סוגים שונים של ירושה. הם ירושה יחידה, ירושה מרובה, ירושה מרובת רמות וירושה היררכית. בירושה יחידה, יש מחלקה בסיס אחת ומחלקה נגזרת אחת.בירושה מרובת רמות, ישנן שלוש מחלקות, כלומר, מחלקה בסיס, מחלקה ביניים ומחלקה נגזרת. מחלקת הביניים יורשת מהמחלקה הבסיסית, והמחלקה הנגזרת יורשת ממחלקת הביניים. בירושה היררכית, יש מחלקת בסיס אחת ומחלקות נגזרות רבות. יש סוג מיוחד המכונה הורשה היברידית. זהו שילוב של שני סוגי ירושה או יותר.
איור 01: ירושה
בירושה מרובה ישנן מחלקות בסיס רבות ומחלקה נגזרת אחת. נניח שמחלקות A ו-B הן מחלקות הבסיס. מחלקה C היא המחלקה הנגזרת. אם גם למחלקות A וגם למחלקות B יש אותה שיטה והמתכנת קורא לשיטה זו מהמחלקה הנגזרת, זה יגרום לבעיית אי בהירות. ירושה של שתי מחלקות עלולה לגרום לשגיאה בזמן הידור.לכן, ירושה מרובה אינה נתמכת ב-Java. ניתן להשתמש בממשק כדי להתגבר על בעיה זו.
מהו ממשק ב-Java?
Abstraction הוא תהליך של הסתרת פרטי היישום והצגת הפונקציונליות בלבד למשתמש. ניתן להשיג הפשטה באמצעות מחלקות מופשטות או ממשקים. שיטה מופשטת היא שיטה ללא יישום. מחלקה עם שיטה מופשטת אחת לפחות היא מחלקה מופשטת. דוגמה למחלקה מופשטת היא כדלקמן.
מחלקה אבסטרקטית A{
abstract void sum();
}
נניח שישנן שתי מחלקות מופשטות כמו A ו-B. כדי ליישם שיטות מופשטות של A ו-B, נוצרת מחלקה C חדשה. אז מחלקה C צריכה להרחיב גם את A וגם B., אבל ירושה מרובה לא נתמכת ב-Java. לכן, צריך להשתמש בממשקים. ניתן להשתמש בממשקים כדי להכריז על שיטות, אך לא ניתן להגדיר שיטות. לא ניתן ליצור אובייקט באמצעות ממשקים. Class C צריך ליישם את כל השיטות בממשק A ו-B.
ממשק A{
void sum();
}
ממשק B{
void sub();
}
class C מיישם את A, B{
public void sum(){
System.out.println(“Summation”);
}
public void sub(){
System.out.println(“Subtraction”);
}
}
עכשיו, בתוכנית הראשית אפשר ליצור אובייקט של C ולקרוא לשתי השיטות.
public static void main (מחרוזת args) {
C obj=new C();
obj.sum();
obj.sub();
}
אז, ממשקים יכולים להשתמש כדי ליישם ירושה מרובה.
שימוש נוסף בממשקים הוא שהם מספקים אבטחה. עיין בקוד שלהלן.
ממשק A {
void sum ();
}
class B מיישם את A {
סכום ביטול ציבורי () {
System.out.println(“Summation”);
}
public void multiply () {
System.out.println("כפל");
}
}
כאשר יוצרים אובייקט של B, אפשר לקרוא לשתי השיטות סכום () וכפל (). אם המתכנת רוצה להגביל שימוש בפונקציית הכפל (), זה אפשרי כדלקמן.
public static void main(String args){
A obj=new B();
obj.sum();
}
A obj=new B(); תיצור אובייקט. הוא מסוג A והזיכרון מוקצה כ-B. אפשר לקרוא sum() אך לא ניתן לבצע multiply(). הגבלה זו נעשית באמצעות ממשקים.
מהם הדמיון בין ירושה לממשק ב-Java?
- שני המושגים קשורים לתכנות מונחה עצמים
- שניהם מייצגים מערכת יחסים IS-A.
מה ההבדל בין ירושה לממשק ב-Java?
ירושה לעומת ממשק ב-Java |
|
| ירושה הוא קונספט OOP להפקת מחלקות חדשות מהמחלקות הקיימות. | Interface הוא מנגנון ב-OOP ליישום הפשטה והורשה מרובה. |
| שימוש | |
| ירושה מספקת שימוש חוזר בקוד. | ממשקים מספקים הפשטה והורשה מרובה. |
סיכום – ירושה לעומת ממשק ב-Java
Java היא שפת תכנות מרובת פרדיגמות התומכת בתכנות מונחה עצמים.ירושה וממשקים קשורים לתכנות מונחה עצמים. ההבדל בין ירושה לממשק הוא שהירושה היא להפיק מחלקות חדשות ממחלקות קיימות וממשקים היא ליישם מחלקות מופשטות וירושה מרובה.
הורד את גרסת ה-PDF של ירושה לעומת ממשק ב-Java
ניתן להוריד את גרסת ה-PDF של מאמר זה ולהשתמש בה למטרות לא מקוונות לפי הערת ציטוט. אנא הורד כאן גרסת PDF ההבדל בין ירושה לממשק ב-Java
