דריסת שיטה ב-Java

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

public class Animal {

   public void speak() {

       System.out.println("Hello!");
   }
}

למרות שרק התחלנו לכתוב את התוכנית, אתה כנראה רואה בעיה פוטנציאלית: יש הרבה בעלי חיים בעולם, וכולם 'מדברים' אחרת: חתולים מיאו, ברווזים מקרקרים ונחשים שושנים. המטרה שלנו פשוטה: להימנע מיצירת המון שיטות דיבור. במקום ליצור שיטת catSpeak() למיאו, שיטת snakeSpeak() לשריקה וכו', אנו רוצים לקרוא לשיטת speak() ושהנחש ישרש, החתול מיאו והכלב ינבח. אנו יכולים להשיג זאת בקלות באמצעות דחיפת שיטה. ויקיפדיה נותנת את ההסבר הבא למונח 'עקיפה': עקיפה של שיטה, בתכנות מונחה עצמים, היא תכונת שפה המאפשרת לתת-מחלקה או מחלקה ילד לספק יישום ספציפי של שיטה שכבר מסופקת על ידי אחת ממחלקות העל שלה או כיתות הורים זה בעצם נכון. עקיפת שיטה מאפשרת לך לקחת שיטה כלשהי של כיתת האב ולכתוב יישום משלך בכל כיתת ילד. היישום החדש 'מחליף' את יישום ההורה בכיתת הילד. בוא נראה איך זה נראה בדוגמה. צור 4 כיתות שיורשות את כיתת החיות שלנו :

public class Bear extends Animal {
   @Override
   public void speak() {
       System.out.println("Growl!");
   }
}
public class Cat extends Animal {

   @Override
   public void speak() {
       System.out.println("Meow!");
   }
}

public class Dog extends Animal {

   @Override
   public void speak() {
       System.out.println("Woof!");
   }
}


public class Snake extends Animal {

   @Override
   public void speak() {
       System.out.println("Hiss!");
   }
}

"הנה תקלה קטנה לעתיד: כדי לעקוף את השיטות של כיתת האב, עבור אל הקוד של כיתת הילד ב-IntelliJ IDE, לחץ על Ctrl+O ובחר "עקוף שיטות..." בתפריט. התרגל להשתמש במקשים חמים מההתחלה - זה יעזור לך לכתוב תוכניות מהר יותר! כדי לציין את ההתנהגות שאנחנו צריכים, עשינו כמה דברים:

1. בכל כיתת ילד יצרנו שיטה בעלת שם זהה לשיטת כיתת האב.


2. אמרנו למהדר ששם השיטה זהה לזה של מחלקת האב אינו מקרי: אנחנו רוצים לעקוף את ההתנהגות שלה. כדי לתקשר את זה למהדר, הגדרנו את ההערה @Override מעל השיטה.
   כאשר ממוקמים מעל שיטה, ההערה @Override מודיעה למהדר (כמו גם למתכנתים הקוראים את הקוד שלך): 'הכל בסדר. זו לא טעות. אני לא שוכח. אני מודע לכך ששיטה כזו כבר קיימת ואני רוצה לעקוף אותה'.


3. כתבנו את היישום שאנו צריכים עבור כל כיתת ילד. כאשר קוראים לשיטת speak() נחש צריך לשרוק, דוב צריך לנהום וכו'.

בוא נראה איך זה עובד בתוכנית:

public class Main {

   public static void main(String[] args) {

       Animal animal1 = new Dog();
       Animal animal2 = new Cat();
       Animal animal3 = new Bear();
       Animal animal4 = new Snake();

       animal1.speak();
       animal2.speak();
       animal3.speak();
       animal4.speak();
   }
}

פלט מסוף:

Woof!
Meow!
Growl!
Hiss!

מְעוּלֶה! הכל עובד כמו שצריך! יצרנו 4 משתני התייחסות המאחסנים אובייקטים של מחלקת האב Animal , והקצנו להם מופעים של 4 מחלקות ילד שונות. כתוצאה מכך, כל חפץ מפגין התנהגות משלו. עבור כל כיתת ילד, שיטת speak() החליפה את השיטה 'native' speak() במחלקה Animal (שפשוט מציגה 'Hello!'). לעקוף מספר מגבלות:

1. השיטה הנעקפת חייבת להיות בעלת אותם פרמטרים כמו שיטת האב.

   אם לשיטת ה- speak של מחלקת האב יש פרמטר String , השיטה הנעקפת במחלקה הילד חייבת להיות בעלת פרמטר String . אחרת, המהדר יפיק שגיאה:

   public class Animal {
   
      public void speak(String s) {
   
          System.out.println("Hello! " + s);
      }
   }
   
   public class Cat extends Animal {
   
      @Override // Error!
      public void speak() {
          System.out.println("Meow!");
      }
   }




2. השיטה הנעקפת חייבת להיות בעלת סוג החזרה כמו שיטת האב.

   אחרת, נקבל שגיאת מהדר:

   public class Animal {
   
      public void speak() {
   
          System.out.println("Hello!");
      }
   }
   
   
   public class Cat extends Animal {
   
      @Override
      public String speak() {         // Error!
          System.out.println("Meow!");
          return "Meow!";
      }
   }




3. גם משנה הגישה בשיטה הנדחקת חייב להיות זהה לשיטה 'המקורית':

   public class Animal {
   
         public void speak() {
   
               System.out.println("Hello!");
         }
   }
   
   public class Cat extends Animal {
   
          @Override
          private void speak() {      // Error!
              System.out.println("Meow!");
          }
   }

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