שיעורים אנונימיים בג'אווה

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

public interface MonitoringSystem {

   public void startMonitoring();
}

זה מיושם על ידי 3 מחלקות ספציפיות:

public class GeneralIndicatorsMonitoringModule implements MonitoringSystem {

@Override
   public void startMonitoring() {
       System.out.println("Monitoring of general indicators has started!");
   }
}


public class ErrorMonitoringModule implements MonitoringSystem {

   @Override
   public void startMonitoring() {
       System.out.println("Bug Tracking Monitoring Started!");
   }
}


public class SecurityModule implements MonitoringSystem {

   @Override
   public void startMonitoring() {
       System.out.println("Security monitoring started!");
   }
}

נראה שהכל מסודר. יש לנו מערכת די ברורה של מספר מודולים. לכל אחד מהם התנהגות משלו. אם אנחנו צריכים מודולים חדשים, אנחנו יכולים להוסיף אותם, כי יש לנו ממשק די קל ליישום. אבל בואו נחשוב איך מערכת הניטור שלנו תעבוד. בעיקרו של דבר, עלינו פשוט ליצור 3 אובייקטים - GeneralIndicatorsMonitoringModule, ErrorMonitoringModule, SecurityModule- ולקרוא שיטה startMonitoring()על כל אחד מהם. כלומר, כל מה שאתה צריך לעשות הוא ליצור 3 אובייקטים ולקרוא עליהם שיטה 1.

public class Main {

   public static void main(String[] args) {

       GeneralIndicatorsMonitoringModule generalModule = new GeneralIndicatorsMonitoringModule();
       ErrorMonitoringModule errorModule = new ErrorMonitoringModule();
       SecurityModule securityModule = new SecurityModule();

       generalModule.startMonitoring();
       errorModule.startMonitoring();
       securityModule.startMonitoring();
   }
}

פלט מסוף:

Мониторинг общих показателей стартовал!
Мониторинг отслеживания ошибок стартовал!
Мониторинг безопасности стартовал!

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

public class Main {

   public static void main(String[] args) {

       MonitoringSystem generalModule = new MonitoringSystem() {
           @Override
           public void startMonitoring() {
               System.out.println("Monitoring of general indicators has started!");
           }
       };



           MonitoringSystem errorModule = new MonitoringSystem() {
           @Override
           public void startMonitoring() {
               System.out.println("Bug Tracking Monitoring Started!");
           }
       };

       MonitoringSystem securityModule = new MonitoringSystem() {
           @Override
           public void startMonitoring() {
               System.out.println("Security monitoring started!");
           }
       };

       generalModule.startMonitoring();
       errorModule.startMonitoring();
       securityModule.startMonitoring();
   }
}

בואו להבין מה קורה כאן! זה נראה כאילו אנחנו יוצרים אובייקט ממשק:

MonitoringSystem generalModule = new MonitoringSystem() {

@Override
   public void startMonitoring() {
       System.out.println("Monitoring of general indicators has started!");
   }
};

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

MonitoringSystem generalModule = new MonitoringSystem() {

};

בתוך מכונת ה-Java מתרחשים הדברים הבאים:

1. נוצרת מחלקת Java ללא שם המיישמת את ה- MonitoringSystem.
2. המהדר, כשהוא רואה מחלקה כזו, מחייב אותך ליישם את כל שיטות הממשק MonitoringSystem(עשינו זאת 3 פעמים).
3. נוצר אובייקט אחד מהמחלקה הזו. שימו לב לקוד:

MonitoringSystem generalModule = new MonitoringSystem() {

};

יש נקודה-פסיק בסוף! היא עומדת שם מסיבה כלשהי. אנו מכריזים בו-זמנית על מחלקה (באמצעות סוגרים מסולסלים) ויוצרים את האובייקט שלה באמצעות (); כל אחד משלושת האובייקטים שלנו דרס שיטה startMonitoring()בדרכו שלו. בסוף אנחנו פשוט קוראים לשיטה הזו על כל אחד מהם:

generalModule.startMonitoring();
errorModule.startMonitoring();
securityModule.startMonitoring();

פלט מסוף:

Мониторинг общих показателей стартовал!
Мониторинг отслеживания ошибок стартовал!
Мониторинг безопасности стартовал!

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

MonitoringSystem generalModule = new MonitoringSystem() {

   @Override
   public void startMonitoring() {
       System.out.println("Monitoring of general indicators has started!");
   }

   public void someSpecificMethod() {

       System.out.println("Specific method for first module only");
   }
};

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

public class Main {

   private static int currentErrorsCount = 23;

   public static void main(String[] args) {

       MonitoringSystem errorModule = new MonitoringSystem() {

           @Override
           public void startMonitoring() {
               System.out.println("Bug Tracking Monitoring Started!");
           }

           public int getCurrentErrorsCount() {

               return currentErrorsCount;
           }
       };
   }
}

יש להם משהו במשותף עם מחלקות מקומיות: הם גלויים רק בתוך השיטה שבה הם מוגדרים. בדוגמה למעלה, כל ניסיון לגשת לאובייקט errorModuleמחוץ לשיטה main()ייכשל. ועוד מגבלה חשובה שמחלקות אנונימיות ירשו מ"אבותיהם" - מחלקות פנימיות: מחלקה אנונימית אינה יכולה להכיל משתנים ושיטות סטטיות . אם ננסה להפוך את השיטה getCurrentErrorsCount()מהדוגמה שלמעלה לסטטית, המהדר יזרוק שגיאה:

//error! Inner classes cannot have static declarations
public static int getCurrentErrorsCount() {

   return currentErrorsCount;
}

נקבל את אותה תוצאה אם ​​ננסה להכריז על משתנה סטטי:

MonitoringSystem errorModule = new MonitoringSystem() {

   //error! Inner classes cannot have static declarations!
   static int staticInt = 10;

   @Override
   public void startMonitoring() {
       System.out.println("Bug Tracking Monitoring Started!");
   }

};

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