爲什麼要以這種方式使用「靜態」類？

我有一個FutureContent類，它只保存一個Future類的靜態引用。我不確定爲什麼這樣做，這意味着現在每個方法調用都不必是靜態的。這是否有另外一個原因呢？爲什麼要以這種方式使用「靜態」類？

//One possible use of Future class 
    FutureContent.future.deleteContent("test"); 

    public class FutureContent { 
      public static Future future = new Future(); 
    } 


public class Future{ 
     private final Object lock = new Object(); 

     private String str; 

     private Hashtable content = new Hashtable(); 

     public void addContent(Object key, Object value){ 

      synchronized(lock){ 
       if(content.containsKey(key)){ 
        content.remove(key); 
        content.put(key, value); 
       } 
       else { 
        content.put(key, value); 
       } 
      } 
     } 

     public void clearContent(){ 
      content.clear(); 
     } 

     public void deleteContent(Object key){ 
       if(content.containsKey(key)){ 
        content.remove(key); 
       } 
     } 

     public boolean getBoolean(Object key){ 
      if(!content.contains(key)){ 
       return false; 
      } 
      else { 
       return ((Boolean)content.get(key)).booleanValue(); 
      } 
     } 

     public void addBoolean(Object key , boolean value){ 

      Boolean b = new Boolean(value); 

      synchronized(lock){ 
       if(content.containsKey(key)){ 
        content.remove(key); 
        content.put(key, b); 
       } 
       else { 
        content.put(key, b); 
       } 
      } 
     } 

     public Object getContent(Object key){ 
       return content.get(key); 
     } 

     public void setString(String str){ 
      synchronized(lock){ 
       this.str = str; 
       lock.notifyAll(); 
      } 

     } 

     public String getString(){ 
      synchronized(lock){ 
        while(this.str == null) 
        try { 
         lock.wait(); 
        } catch (InterruptedException e) { 
         return null; 
        } 
        return this.str; 
      } 
    } 


     private JSONObject value; 
     public void set(JSONObject t){ 
      synchronized(lock){ 
       value = t; 
       lock.notifyAll(); 
      } 
     } 

     public JSONObject get(){ 
     synchronized(lock){ 
       while(value == null) 
       try { 
        lock.wait(); 
       } catch (InterruptedException e) { 
        return null; 
       } 

       return value; 
     } 

     }  
    }

來源

2011-12-04 blue-sky

單身的所有樂趣，沒有所有那些惱人的訪問控制！ – cHao

是的，這只是一個單例（一個非線程安全的，BTW） –

這是一種提供預分配對象的方法，該對象通常是不可變的，可以跨實例共享。一個常見的例子是Collections.EMPTY_LIST與簽名

public static final List EMPTY_LIST = new EmptyList<Object>();

來源

2011-12-04 10:53:46

不是一個很好的示例，因爲它需要原始類型。 IIRC，JDK8中有一個'emptySorterSet'，但沒有相應的（公共）靜態字段。 –

這是一種在Java中使用全局變量的方法。儘管我們不能直接在Java中創建全局變量，但我們可以使用public和static修飾符實現幾乎相同的效果。儘管全局變量有很多缺點，但它也有一些優點。我們可以輕鬆地從一個地方交換數據，而且這些數據將隨處可見。即，您可以在不同的模塊和類之間存儲和訪問公共數據，而無需在它們之間傳遞數據。但要小心！ - :)

來源

2011-12-04 10:53:16 Jomoos

[Mutable]全局變量非常非常調皮。可怕的設計導致可讀性差，可測試性，依賴性，可移植性，可維護性，安全性等。 –

爲什麼要以這種方式使用「靜態」類？

回答

相關問題