अनाम वर्ग

नमस्ते! आज के पाठ में, हम नेस्टेड कक्षाओं के विषय की जाँच करना जारी रखेंगे। अब अंतिम समूह का समय है: अनाम आंतरिक वर्ग। आइए अपने आरेख पर लौटें: स्थानीय वर्गों की तरह, जिनके बारे में हमने पिछले पाठ में बात की थी, अनाम वर्ग एक प्रकार का आंतरिक वर्ग है... उनमें भी कई समानताएँ और अंतर हैं। लेकिन पहले, आइए इसमें गोता लगाएँ: वास्तव में उन्हें "गुमनाम" क्यों कहा जाता है? इसका उत्तर देने के लिए, एक साधारण उदाहरण पर विचार करें। कल्पना कीजिए कि हमारे पास एक बुनियादी कार्यक्रम है जो लगातार चल रहा है और कुछ कर रहा है। हम इस कार्यक्रम के लिए कई मॉड्यूल से बना एक निगरानी प्रणाली बनाना चाहते हैं। एक मॉड्यूल प्रदर्शन के सामान्य संकेतकों को ट्रैक करेगा और एक लॉग बनाए रखेगा। दूसरा त्रुटि लॉग में त्रुटियों को पंजीकृत और रिकॉर्ड करेगा। तीसरा संदिग्ध गतिविधि को ट्रैक करेगा: उदाहरण के लिए, अनधिकृत पहुंच प्रयास और सुरक्षा संबंधी अन्य चीजें। क्योंकि सभी तीन मॉड्यूल, संक्षेप में, केवल कार्यक्रम की शुरुआत में शुरू होने चाहिए और पृष्ठभूमि में चलने चाहिए,

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

ओरेकल दस्तावेज एक अच्छी सिफारिश प्रदान करता है: "[अनाम वर्ग] का प्रयोग करें यदि आपको केवल एक बार स्थानीय कक्षा का उपयोग करने की आवश्यकता है।" एक अनाम वर्ग एक पूर्ण आंतरिक वर्ग है। तदनुसार, इसकी बाहरी वर्ग के चरों तक पहुंच है, जिसमें स्थिर और निजी चर शामिल हैं:

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

};

और आज हमारा पाठ समाप्त हो गया है! लेकिन भले ही हमने नेस्टेड कक्षाओं के अंतिम समूह की जांच की हो, हमने अभी तक इस विषय को समाप्त नहीं किया है। नेस्टेड कक्षाओं के बारे में हम और क्या सीखेंगे? आप निश्चित रूप से जल्द ही पता लगा लेंगे! :)