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

הרחבת מחלקות מרובות ב-Java

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

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

Java היפוך מיתר

הרחבת מחלקות מרובות ב-Java

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

כיתת החיה תכיל שיטה בשם 'לאכול' שמדפיסה 'חיה אוכלת'. כיתת היונקים תרחיב את כיתת החיות ותכיל שיטה בשם 'drinkMilk' שמדפיסה 'יונק שותה חלב'. מחלקת הזוחלים תרחיב גם את מחלקת החיות ותכיל שיטה הנקראת 'layEggs' שמדפיסה את 'זוחל מטיל ביצים'.

הנה הקוד לשיעור בעלי חיים:

 public class Animal { public void eat() { System.out.println('Animal is eating.'); } } 

הנה הקוד למחלקת היונקים:

dateformat.format

 public class Mammal extends Animal { public void drinkMilk() { System.out.println('Mammal is drinking milk.'); } } 

הנה הקוד למחלקת הזוחלים:

 public class Reptile extends Animal { public void layEggs() { System.out.println('Reptile is laying eggs.'); } } 

עכשיו בואו ניצור את ממשק ה-Omnivore, שירחיב את כיתות החיות והיונקים:

 public interface Omnivore extends Animal, Mammal { public void eatPlants(); } 

לבסוף, בואו ניצור את מחלקת Platypus, שתטמיע את ממשק Omnivore:

 public class Platypus implements Omnivore { public void eat() { System.out.println('Platypus is eating.'); } public void drinkMilk() { System.out.println('Platypus is drinking milk.'); } public void eatPlants() { System.out.println('Platypus is eating plants.'); } } 

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

בואו נבדוק את התוכנית שלנו על ידי יצירת מופע של המחלקה Platypus וקריאה לשיטות שלה:

 public class Main { public static void main(String[] args) { Platypus p = new Platypus(); p.eat(); p.drinkMilk(); p.eatPlants(); } } 

תְפוּקָה:

 Platypus is eating. Platypus is drinking milk. Platypus is eating plants. 

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

מתי להשתמש בהתנהגות דמוית ירושה מרובה ב-Java

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

k אלגוריתם השכן הקרוב

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

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