內部類。它的目的是什麼？

Question

有人可以告訴我什麼是有內部類的目的嗎？我能想到一些，但可能它們不是使用內部類的好理由。我的推理是，當你想使用一個沒有其他類可以使用的類時，內部類是有幫助的。還有什麼？

Answer 1

內部類可用於模擬封閉：http://en.wikipedia.org/wiki/Closure_(computer_science)#Java

Answer 2

內部使用鏈表來存儲元素的列表實現可以很好地利用內部類來表示列表中的節點。我認爲你已經達成共識，說你會使用這樣一個班級，你希望在班級內部使用這樣的班級，但不想讓班級暴露出來 - 這是一個「一次性」的班級，只是非常有用'這裏'。

Answer 3

當我學習Java時，我們使用內部類作爲GUI事件處理類。它是一種「一次性使用」類，不需要其他類可用，並且只與它所在的類有關。

Answer 4

在通過繼承而不相關的多個類具有概念上類似的實現細節的情況下，我使用內部類（以C++），這些細節構成了公共接口的隱式部分，並且應該以相似的方式命名。

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

我使用內部類來定義最好由包含類表示的結構，但不一定有意義使用單獨的外部類來表示結構。

舉一個例子，我有一個類表示一個特定類型的網絡設備，並且該類具有可以在該設備上運行的某些類型的測試。對於每個測試，還有一組潛在的錯誤可以找到。每種類型的設備可能具有不同的錯誤結構。

有了這個，你可以做這樣的事情

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

用方法是從內部類，像

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

當然還有其他方法可以做到這一點，這只是一個內部一流的方法。

簡體（又名不完全）爲上面的代碼：

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