فئات مجهولة في جافا

مرحبًا! في درس اليوم سوف نستمر في النظر إلى موضوع الطبقات المتداخلة. لقد حان دور المجموعة الأخيرة - الطبقات الداخلية المجهولة في جافا. دعونا نعود إلى الرسم البياني الخاص بنا: مثل الطبقات المحلية التي تحدثنا عنها في المحاضرة الأخيرة، الطبقات المجهولة هي مجموعة فرعية من الطبقات الداخلية. لديهم أيضا العديد من أوجه التشابه والاختلاف بينهما. ولكن أولاً، دعونا نكتشف ذلك: لماذا يطلق عليهم في الواقع اسم "مجهول"؟ للقيام بذلك، دعونا نلقي نظرة على مثال بسيط. تخيل أن لدينا برنامجًا رئيسيًا يعمل باستمرار ويفعل شيئًا ما. نريد إنشاء نظام مراقبة لهذا البرنامج يتكون من عدة وحدات. ستقوم إحدى الوحدات بمراقبة مؤشرات الأداء العامة والاحتفاظ بسجل، بينما ستقوم الوحدة الثانية بتسجيل الأخطاء وتسجيلها في سجل الأخطاء، وتقوم الوحدة الثالثة بمراقبة الأنشطة المشبوهة: على سبيل المثال، محاولات الوصول غير المصرح بها والأشياء الأخرى المتعلقة بالأمان. نظرًا لأن الوحدات الثلاث يجب أن تبدأ في بداية البرنامج وتعمل في الخلفية، فمن الجيد إنشاء واجهة مشتركة لها:

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 كائنات واستدعاء طريقة واحدة عليها.

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() {

};

داخل جهاز جافا يحدث ما يلي:

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!");
   }

};

أخيرًا، يمكنني أن أرشح لك مقطع فيديو ممتازًا حول موضوع الفصول المجهولة، حيث يتم شرح هذا الموضوع ببساطة ووضوح قدر الإمكان :) وقد انتهى درسنا اليوم! وعلى الرغم من أننا قمنا بتغطية المجموعة الأخيرة من الفئات المتداخلة، إلا أننا لم ننته من هذا الموضوع بعد. ماذا سندرس بعد ذلك عن الطبقات المتداخلة؟ بالتأكيد ستكتشف ذلك قريبًا! :)