इनर क्लास। इसका उद्देश्य क्या है?

Question

क्या कोई मुझे बता सकता है कि आंतरिक कक्षाओं का उद्देश्य क्या है? मैं कुछ के बारे में सोच सकता हूं लेकिन हो सकता है कि वे आंतरिक कक्षाओं का उपयोग करने के अच्छे कारण न हों। मेरा तर्क यह है कि आंतरिक वर्ग सहायक होता है जब आप उस वर्ग का उपयोग करना चाहते हैं जिसमें कोई अन्य वर्ग उपयोग नहीं कर सकता है। और क्या?

Answer 1

इनर कक्षाएं बंद अनुकरण करने के लिए इस्तेमाल किया जा सकता: http://en.wikipedia.org/wiki/Closure_(computer_science)#Java

शायद

Answer 2

एक सूची कार्यान्वयन जो आंतरिक रूप से तत्वों को स्टोर करने के लिए एक लिंक्ड सूची का उपयोग करता है, सूची के भीतर नोड्स का प्रतिनिधित्व करने के लिए आंतरिक कक्षा का अच्छा उपयोग कर सकता है। मुझे लगता है कि आपने यह कहते हुए सिर पर नाखून मारा है कि आप इस तरह के एक वर्ग का उपयोग करेंगे जहां आप इसे कक्षा में आंतरिक रूप से उपयोग करना चाहते हैं, लेकिन यह नहीं चाहते कि यह खुलासा हो - एक 'एक ऑफ' वर्ग जो केवल वास्तव में उपयोगी है 'यहाँ'।

Answer 3

जब मैं जावा सीख रहा था तो हमने जीयूआई इवेंट हैंडलिंग कक्षाओं के लिए आंतरिक कक्षाओं का उपयोग किया। यह एक "एक बार उपयोग" वर्ग है जो अन्य वर्गों के लिए उपलब्ध नहीं होना चाहिए, और केवल उस वर्ग के लिए प्रासंगिक है जिसमें यह रहता है।

Answer 4

मैं परिस्थितियों में आंतरिक कक्षाओं (सी ++ में) का उपयोग करता हूं जहां विरासत के माध्यम से असंबद्ध कई वर्गों में अवधारणात्मक रूप से समान कार्यान्वयन विवरण होते हैं, जो सार्वजनिक इंटरफ़ेस का एक निहित हिस्सा होते हैं और उन्हें समान रूप से नामित किया जाना चाहिए।

class lib::Identifier { ... }; 

class lib::Person { 
public: 
    class Identifier : public lib::Identifier { ... }; 
}; 

class lib::File { 
public: 
    class Identifier : public lib::Identifier { ... }; 
}; 

यह यह सुविधाजनक उचित कार्यक्षेत्रों में, Identifier, Person::Identifier, और File::Identifier के रूप में बस Identifier का उल्लेख है।

Answer 5

मैं आंतरिक कक्षाओं का उपयोग उस संरचना को परिभाषित करने के लिए करता हूं जो कि युक्त वर्ग द्वारा सबसे अच्छा प्रतिनिधित्व करता है, लेकिन संरचना का प्रतिनिधित्व करने के लिए एक अलग बाहरी वर्ग का उपयोग करने के लिए जरूरी नहीं है।

उदाहरण देने के लिए मेरे पास एक वर्ग है जो किसी विशेष प्रकार के नेटवर्क डिवाइस का प्रतिनिधित्व करता है, और कक्षा में कुछ प्रकार के परीक्षण होते हैं जिन्हें उस डिवाइस पर चलाया जा सकता है। प्रत्येक परीक्षण के लिए त्रुटियों का संभावित सेट भी मिलता है जो पाया जा सकता है। प्रत्येक प्रकार के डिवाइस में त्रुटियों के लिए एक अलग संरचना हो सकती है।

इस के साथ

आप की तरह

for (Error error : errors) { 
     System.out.println("MOnitor Type: " + error.getMonType()); 
     ... 
    } 

बेशक वहाँ यह करने के लिए अन्य तरीके हैं जैसे

List<Error> errors = RemoteDeviceA.getErrors(); 

तरीकों भीतरी वर्ग से उपलब्ध होने के साथ

बातें कर सकता है, यह सिर्फ एक आंतरिक है कक्षा दृष्टिकोण।

सरलीकृत (उर्फ अधूरा) के ऊपर के लिए कोड:

public class RemoteDeviceA { 

    private String host; 
    private String user; 
    private String password; 
    private static List<Error> errors; 

    public RemoteDeviceA(String user, String host, String password) { 
     this.host = host; 
     this.user = user; 
     this.password = password; 

     login(); 
    } 

    private void login() { 
     // Logs in 
    } 

    public void runTestA() { 

     List<Error> errorList = new ArrayList<Error>(); 

     //loop through test results 

     if (!value.equals("0")) { 
      Error error = new Error(node, rackNum, shelfNum, slotNum, monType, value); 
      if (error.isError()) { 
       errorList.add(error); 
      } 
     } 
     setErrors(errorList); 
    } 

    private static void setErrors(List<Error> errors) { 
     RemoteDeviceA.errors = errors; 
    } 

    public List<Error> getErrors() { 
     return errors; 
    } 

    public class Error { 

     private String monType; 
     private String node; 
     private String rack; 
     private String shelf; 
     private String slot; 
     private String value; 
     private boolean error = false; 
     private boolean historyError = false; 
     private boolean critical = false; 
     private boolean criticalHistory = false; 

     Error(String node, String rack, String shelf, String slot, 
       String monType, String value) { 
      parseAlarm(node, rack, shelf, slot, monType, value); 
     } 

     private void parseAlarm(String node, String rack, String shelf, 
       String slot, String monType, String value) { 

      String modType = ""; 

      if (monType.startsWith("ES_15") && !value.equals("0")) { 
       setMonType("ES_15"); 
       setError(true); 
      } else if (monType.startsWith("SES_15") && !value.equals("0")) { 
       setMonType("SES_15"); 
       setError(true); 
      } else if (monType.startsWith("BBE_15") && !value.equals("0")) { 
       setMonType("BBE_15"); 
       setError(true); 
      } else if (monType.startsWith("UT_15") && !value.equals("0")) { 
       setMonType("UT_15"); 
       setError(true); 
       setCritial(critical); 
      } else if (monType.startsWith("ES_24") && !value.equals("0")) { 
       setMonType("ES_24"); 
       setHistoryError(true); 
       setError(true); 
      } else if (monType.startsWith("SES_24") && !value.equals("0")) { 
       setMonType("SES_24"); 
       setHistoryError(true); 
       setError(true); 
      } else if (monType.startsWith("BBE_24") && !value.equals("0")) { 
       setMonType("BBE_24"); 
       setHistoryError(true); 
       setError(true); 
      } else if (monType.startsWith("UT_24") && !value.equals("0")) { 
       setMonType("UT_24"); 
       setHistoryError(true); 
       setError(true); 
       setCriticalHistory(true); 
      } else if (monType.startsWith("UT_15") && !value.equals("0")) { 
       setMonType("UT_15"); 
       setError(true); 
       setCritial(true); 
      } else if (monType.startsWith("LASPWR")) { 

       float laserPwr = Float.valueOf(value); 

       if (node.startsWith("LEM_EM")) { 
        if ((laserPwr < 8.0) || (laserPwr > 12.0)) { 
         setMonType("LASERPWR"); 
         setError(true); 
        } 
       } else if (node.startsWith("LEM10")) { 
        if ((laserPwr < 18.0) || (laserPwr > 22.0)) { 
         setMonType("LASERPWR"); 
         setError(true); 
        } 
       } 
      } 

      if (isError()) { 
       setNode(node); 
       setRack(rack); 
       setShelf(shelf); 
       setSlot(slot); 
       setValue(value); 
       setError(true); 
      } 
     } 

     private void setMonType(String monType) { 
      this.monType = monType; 
     } 

     public String getMonType() { 
      return monType; 
     } 

     private void setNode(String node) { 
      this.node = node; 
     } 

     public String getNode() { 
      return node; 
     } 

     public void setRack(String rack) { 
      this.rack = rack; 
     } 

     public String getRack() { 
      return rack; 
     } 

     public void setShelf(String shelf) { 
      this.shelf = shelf; 
     } 

     public String getShelf() { 
      return shelf; 
     } 

     public void setSlot(String slot) { 
      this.slot = slot; 
     } 

     public String getSlot() { 
      return slot; 
     } 

     private void setValue(String value) { 
      this.value = value; 
     } 

     public String getValue() { 
      return value; 
     } 

     private void setError(boolean error) { 
      this.error = error; 
     } 

     public boolean isError() { 
      return error; 
     } 

     public void setCritial(boolean critical) { 
      this.critical = critical; 
     } 

     public boolean isCritical() { 
      return critical; 
     } 

     public void setCriticalHistory(boolean criticalHistory) { 
      this.criticalHistory = criticalHistory; 
     } 

     public boolean isCriticalHistory() { 
      return criticalHistory; 
     } 

     public void setHistoryError(boolean historyError) { 
      this.historyError = historyError; 
     } 

     public boolean isHistoryError() { 
      return historyError; 
     } 
    } 
}