گمنام طبقن

سلام اڄ جي سبق ۾، اسان nested طبقن جي موضوع کي جانچڻ جاري رکنداسين. هاڻي اهو آخري گروپ جو وقت آهي: گمنام اندروني طبقن. اچو ته اسان جي ڊرائگرام ڏانھن واپس وڃون: مقامي طبقن وانگر، جن بابت اسان گذريل سبق ۾ ڳالهايو، گمنام طبقن جو ھڪڙو قسم آھي اندروني طبقو... انھن ۾ پڻ ڪيترائي مماثلت ۽ فرق آھن. پر پهرين، اچو ته ان ۾ ٻڏل: ڇو انهن کي "گمنام" سڏيو ويندو آهي؟ هن جو جواب ڏيڻ لاء، هڪ سادي مثال تي غور ڪريو. تصور ڪريو ته اسان وٽ ھڪڙو بنيادي پروگرام آھي جيڪو مسلسل ھلندو آھي ۽ ڪجھھ ڪري رھيو آھي. اسان هن پروگرام لاءِ مانيٽرنگ سسٽم ٺاهڻ چاهيون ٿا، ڪيترن ئي ماڊلز مان ٺهيل آهي. ھڪڙو ماڊل ڪارڪردگي جي عام اشارن کي ٽريڪ ڪندو ۽ لاگ برقرار رکندو. ٻيو رجسٽر ڪندو ۽ غلطي جي لاگ ۾ غلطيون رڪارڊ ڪندو. ٽيون مشڪوڪ سرگرمي کي ٽريڪ ڪندو: مثال طور، غير مجاز رسائي جي ڪوششون ۽ ٻيون سيڪيورٽي سان لاڳاپيل شيون. ڇو ته سڀني ٽن ماڊلز کي گهرجي، جوهر ۾، صرف پروگرام جي شروعات ۾ شروع ٿئي ۽ پس منظر ۾ هلن، اهو هڪ سٺو خيال هوندو انهن لاءِ هڪ عام انٽرفيس ٺاهڻ:

public interface MonitoringSystem {
  
   public void startMonitoring();
}

3 ڪنڪريٽ ڪلاس ان تي عمل ڪندا:

public class GeneralIndicatorMonitoringModule implements MonitoringSystem {
   
@Override
   public void startMonitoring() {
       System.out.println("Starting to monitor general indicators!");
   }
}


public class ErrorMonitoringModule implements MonitoringSystem {

   @Override
   public void startMonitoring() {
       System.out.println("Starting to monitor errors!");
   }
}


public class SecurityModule implements MonitoringSystem {

   @Override
   public void startMonitoring() {
       System.out.println("Starting to monitor security!");
   }
}

اهو لڳي ٿو ته هر شيء ترتيب ۾ آهي. اسان وٽ ھڪڙو خوبصورت مربوط نظام آھي جيڪو ڪيترن ئي ماڊلز مان ٺهيل آھي. انهن مان هر هڪ پنهنجي رويي ڪئي. جيڪڏهن اسان کي نئين ماڊلز جي ضرورت آهي، اسان انهن کي شامل ڪري سگهون ٿا، ڇاڪاڻ ته اسان وٽ هڪ انٽرفيس آهي جيڪو لاڳو ڪرڻ بلڪل آسان آهي. پر اچو ته سوچيون ته اسان جو مانيٽرنگ سسٽم ڪيئن ڪم ڪندو. بنيادي طور تي، اسان کي صرف 3 شيون ٺاهڻ جي ضرورت آهي - GeneralIndicatorMonitoringModule, ErrorMonitoringModule, SecurityModule- ۽ startMonitoring()انهن مان هر هڪ تي طريقو ڪال ڪريو. اھو آھي، جيڪو اسان کي ڪرڻو آھي اھو آھي 3 شيون ٺاھيو ۽ انھن تي 1 ميتھڊ ڪال ڪريو.

public class Main {

   public static void main(String[] args) {

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

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

ڪنسول آئوٽ:

Starting to monitor general indicators! 
Starting to monitor errors! 
Starting to monitor security!

۽ اهڙي ننڍڙي ڪم سان، اسان سڄو سسٽم لکيو آهي: 3 ڪلاس ۽ هڪ انٽرفيس! ۽ اهو سڀ ڪجهه حاصل ڪرڻ لاءِ 6 لائنون ڪوڊ. ٻئي طرف، اسان جا اختيار ڪهڙا آهن؟ خير، اهو تمام سٺو ناهي ته اسان اهي "هڪ ڀيري" ڪلاس لکيا. پر اسان ان کي ڪيئن ٺيڪ ڪري سگهون ٿا؟ هتي گمنام اندروني طبقا اسان جي بچاء لاء ايندا آهن! هتي اهي آهن جيڪي اسان جي صورت ۾ نظر اچن ٿا:

public class Main {

   public static void main(String[] args) {

       MonitoringSystem generalModule = new MonitoringSystem() {
           @Override
           public void startMonitoring() {
               System.out.println("Starting to monitor general indicators!");
           }
       };

       

MonitoringSystem errorModule = new MonitoringSystem() {
           @Override
           public void startMonitoring() {
               System.out.println("Starting to monitor errors!");
           }
       };

       MonitoringSystem securityModule = new MonitoringSystem() {
           @Override
           public void startMonitoring() {
               System.out.println("Starting to monitor security!");
           }
       };

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

اچو ته سمجهون ته ڇا ٿي رهيو آهي! اهو لڳي ٿو ته اسان هڪ انٽرفيس اعتراض ٺاهي رهيا آهيون:

MonitoringSystem generalModule = new MonitoringSystem() {
   
@Override
   public void startMonitoring() {
       System.out.println("Starting to monitor general indicators!");
   }
};

پر اسان گهڻو وقت ڄاڻي چڪا آهيون ته اسان انٽرفيس شيون ٺاهي نٿا سگهون! ۽ ائين ئي آهي - اهو ناممڪن آهي. حقيقت ۾، اهو نه آهي جيڪو اسان ڪري رهيا آهيون. جڏهن اسان لکون ٿا:

MonitoringSystem generalModule = new MonitoringSystem() {
   
};

هيٺ ڏنل جاوا مشين اندر ٿئي ٿو:

1. ھڪڙو نامعلوم جاوا ڪلاس ٺاھيو ويو آھي جيڪو MonitoringSystemانٽرفيس کي لاڳو ڪري ٿو.
2. جڏهن مرتب ڪندڙ اهڙي طبقي کي ڏسي ٿو، اهو توهان کي MonitoringSystemانٽرفيس جي سڀني طريقن کي لاڳو ڪرڻ جي ضرورت آهي (اسان اهو 3 ڀيرا ڪيو).
3. هن طبقي جو هڪ اعتراض ٺهيل آهي. ڪوڊ تي ڌيان ڏيو:

MonitoringSystem generalModule = new MonitoringSystem() {
   
};

آخر ۾ هڪ سيميڪولن آهي! اهو هڪ سبب لاء اتي آهي. اسان هڪ ئي وقت ڪلاس جو اعلان ڪريون ٿا (گهربل ڪنگڻ استعمال ڪندي) ۽ ان جو هڪ مثال ٺاهيو (استعمال ڪندي ();). اسان جي ٽن شين مان هر هڪ startMonitoring()طريقي کي پنهنجي طريقي سان ختم ڪري ٿو. آخرڪار، اسان صرف انهن مان هر هڪ تي هن طريقي کي سڏيندا آهيون:

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

ڪنسول آئوٽ:

Starting to monitor general indicators! 
Starting to monitor errors! 
Starting to monitor security!

بس اهو آهي! اسان پنھنجو مقصد حاصل ڪيو: اسان ٽي MonitoringSystemشيون ٺاھيون، ھڪڙي طريقي کي ٽن مختلف طريقن سان ختم ڪيو، ۽ ان کي ٽي ڀيرا سڏيو. سڀ ٽي ماڊلز ڪاميابي سان سڏيا ويا آهن ۽ هلائي رهيا آهن. ساڳئي وقت، اسان جي پروگرام جي جوڙجڪ تمام آسان ٿي چڪي آهي! آخرڪار، GeneralIndicatorMonitoringModule, ErrorMonitoringModule, ۽ SecurityModuleڪلاس هاڻي مڪمل طور تي پروگرام مان هٽائي سگھجن ٿا! اسان کي صرف انهن جي ضرورت ناهي - اسان انهن کان سواءِ وڏو ڪم ڪيو. جيڪڏهن اسان جي گمنام طبقن مان هر هڪ کي ڪجهه مختلف رويي جي ضرورت آهي، مثال طور ان جا پنهنجا مخصوص طريقا جيڪي ٻين وٽ نه آهن، اسان انهن کي آساني سان شامل ڪري سگهون ٿا:

MonitoringSystem generalModule = new MonitoringSystem() {
  
   @Override
   public void startMonitoring() {
       System.out.println("Starting to monitor general indicators!");
   }
  
   public void someSpecificMethod() {

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

Oracle دستاويز هڪ سٺي سفارش پيش ڪري ٿو : "استعمال ڪريو [گمنام طبقن] جيڪڏهن توهان کي صرف هڪ ڀيرو مقامي ڪلاس استعمال ڪرڻ جي ضرورت آهي." هڪ گمنام طبقو هڪ مڪمل اندروني طبقو آهي. ان جي مطابق، ان کي خارجي طبقي جي متغيرن تائين رسائي آھي، بشمول جامد ۽ نجي متغير:

public class Main {

   private static int currentErrorCount = 23;

   public static void main(String[] args) {

       MonitoringSystem errorModule = new MonitoringSystem() {
          
           @Override
           public void startMonitoring() {
               System.out.println("Starting to monitor errors!");
           }

           public int getCurrentErrorCount() {

               return currentErrorCount;
           }
       };
   }
}

انهن وٽ مقامي طبقن سان ڪجهه مشترڪ آهي: اهي صرف ان طريقي جي اندر ظاهر ٿيندا آهن جنهن ۾ انهن جو اعلان ڪيو ويو آهي. مٿين مثال ۾، طريقي errorModuleجي ٻاهران اعتراض تائين رسائي حاصل ڪرڻ جي ڪا به ڪوشش main()ناڪام ٿيندي. ۽ هتي هڪ وڌيڪ اهم حد آهي ته گمنام طبقن کي سندن "ابن ڏاڏن" (اندروني طبقن) کان ورثي ۾ ملي ٿو: هڪ گمنام طبقو جامد متغير ۽ طريقن تي مشتمل نه ٿو ٿي سگهي . مٿي ڏنل مثال ۾، جيڪڏهن اسان getCurrentErrorCount()طريقي کي جامد بڻائڻ جي ڪوشش ڪندا، مرتب ڪندڙ هڪ غلطي پيدا ڪندو:

// Error! Inner classes cannot have static declarations
public static int getCurrentErrorCount() {

   return currentErrorCount;
}

اسان ساڳيو نتيجو حاصل ڪندا آهيون جيڪڏهن اسان هڪ جامد متغير کي اعلان ڪرڻ جي ڪوشش ڪندا آهيون:

MonitoringSystem errorModule = new MonitoringSystem() {

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

   @Override
   public void startMonitoring() {
       System.out.println("Starting to monitor errors!");
   }

};

۽ اڄ اسان جو سبق پڄاڻي تي پهتو آهي! پر ان جي باوجود اسان نستي طبقن جي آخري گروپ جي تحقيق ڪئي آهي، اسان اڃا تائين هن موضوع کي ختم نه ڪيو آهي. اسان nested طبقن جي باري ۾ وڌيڪ ڇا سکندا؟ توهان ضرور جلد ئي ڳوليندا! :)