Question

我有一个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;
         }

      }    
    }

Answer 1

这是一种提供预分配对象的方法，该对象通常是不可变的，并且可以跨实例共享。一个常见示例是带有签名的Collections.EMPTY_LIST

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

Answer 2

这是一种在Java中使用全局变量的方法。虽然，我们不能直接在Java中创建全局变量，但我们可以使用public和static修饰符实现几乎相同的效果。虽然全局有许多缺点，但它也有一些优点。我们可以轻松地从一个地方交换数据，这将在任何地方反映出来。即，您可以在不同模块和类之间存储和访问公共数据，而不会在它们之间传递数据的任何障碍。但要小心！ - ：）

为什么以这种方式使用“静态”类？

2 个答案: