Should class with only static data need to be instantiated?

Question

I have two classes. 1. Node 2. MixedStateManager

Node class:

Node class maintains the state of nodes in the system. One such data is state.

public class Node
   {   
      private int state;

     public void setState(int s)
     {
      state = s;
     }

     public int getState()
     {
       return state;
     }
    }

MixedStateManager:

MixedStateManager sees if all the nodes in the system are in the same state or not. If the nodes don't have the same value for state value, then the system is said to be in MixedState. I've a variable mixedState for the same. I've made it static because, if the value is changed by one instance of the class, then it should be visible by others. Another thing to note is MixedStateManager is called by different threads which change the value of state of nodes.

public class MixedStateManager{

public static boolean mixedState;

public boolean isMixedState(){
 return mixedState;
}

public void setMixedState(){
// get all instances of Node class;
   if state of all instances are same 
     mixedState = true;
   else
     mixedState = false
}
}

Question: As MixedStateManager has only one data which is static, does it make sense to instantiate this class and then set value. Or can I make all methods static too?

Responses will be appreciated. Thanks

Answer 1

I would argue that no class should ever have static data. That lies the road to testing hell and non-threadsafe code.

Also:

1. Only make methods static if they have zero side-effects (ie only process the data passed as parameters in a deterministic fashion).
2. Do not couple classes, such as having setMixedState rely on accessing Node, pass the method what it needs.

Instead have a method like:

public static bool areNodesMixedState(Node[] nodes) {
    if (state of all instances are same) {
        return true;
    else
        return false
    }
}

Answer 2

You can make it all static, but that will result in (arguably) unnecessary stronger coupling & dependency between the clients of the manager and the manager.

Thus, I agree with @DavidArno on avoiding static state as much as possible.

As @RobertHarvey noted, for logging, I use a static variable to hold a reference to a logger object because maintaining that reference everywhere you might want to add logging can be overly burdensome.

You already have the manager as an object, which is good, so if you need state for the manager, you should move it from the class to the object (by removing the static declaration).

Answer 3

A static class with only static methods and static data is nothing more or less then a collection of global variables and a library of functions disguised as something resembling OO.

Such a class need never be instantiated because the result will not be an object, just an empty shell.