अनामिक वर्ग

हाय! आजच्या धड्यात, आम्ही नेस्टेड क्लासेसच्या विषयाचे परीक्षण करणे सुरू ठेवू. आता शेवटच्या गटाची वेळ आली आहे: अनामित अंतर्गत वर्ग. चला आमच्या आकृतीकडे परत जाऊया: आम्ही गेल्या धड्यात ज्या स्थानिक वर्गांबद्दल बोललो त्याप्रमाणे, अनामिक वर्ग हे एक प्रकारचे अंतर्गत वर्ग आहेत... त्यांच्यातही अनेक समानता आणि फरक आहेत. पण प्रथम, आपण यात डोकावू: त्यांना नेमके "अनामिक" का म्हटले जाते? याचे उत्तर देण्यासाठी, एक साधे उदाहरण विचारात घ्या. कल्पना करा की आपल्याकडे एक मूलभूत प्रोग्राम आहे जो सतत चालू असतो आणि काहीतरी करत असतो. आम्हाला या प्रोग्रामसाठी एक मॉनिटरिंग सिस्टम तयार करायची आहे, जी अनेक मॉड्यूल्सची बनलेली आहे. एक मॉड्यूल कार्यक्षमतेचे सामान्य निर्देशक ट्रॅक करेल आणि लॉग राखेल. दुसरा त्रुटी लॉगमध्ये त्रुटी नोंदवेल आणि रेकॉर्ड करेल. तिसरा संशयास्पद क्रियाकलाप ट्रॅक करेल: उदाहरणार्थ, अनधिकृत प्रवेश प्रयत्न आणि इतर सुरक्षा-संबंधित गोष्टी. कारण तिन्ही मॉड्युल्स, थोडक्यात, फक्त प्रोग्रामच्या सुरूवातीस सुरू होऊन पार्श्वभूमीत चालले पाहिजेत,

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

Java मशीनमध्ये खालील गोष्टी घडतात:

1. एक अनामित Java वर्ग तयार केला जातो जो इंटरफेसची अंमलबजावणी करतो 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!");
   }

};

आणि आमचा आजचा धडा संपला आहे! परंतु आम्ही नेस्टेड क्लासेसच्या शेवटच्या गटाची तपासणी केली असली तरीही आम्ही हा विषय अद्याप पूर्ण केलेला नाही. नेस्टेड क्लासेसबद्दल आपण आणखी काय शिकू? तुम्हाला नक्कीच लवकरच कळेल! :)