how to design if some constants are used by multiple classes

Question

I've few common constants which are used by multiple classes.

What's the most effective way to design in this case:

1. Should I redefine the constants in each class?
2. Or should I separate such constants in a public class, and use the constants (in separate class) within each class?

Or is there any other better approach?

Note:- I'm looking for best OO technique which would be applicable for this.

Answer 1

Constants should be strictly related to some type, they shouldn't just "exist". A Constants class may seem convenient, but it will soon become unmaintainable, not to mention many consider it an antipattern.

It's hard to suggest improvements without seeing your code, but it seems like you need to rethink your design if you find yourself needing the same constants defined in a few different classes outside of the scope of a type.

Answer 2

Providing a Constant Util class is the cleanest way.

class ConstantUtil {
    public static final int MAX_SIZE = 1<<10;
}

The typical folder heirarchy is like this

com.example.util.ConstantUtil

Answer 3

If the contants are dedicated to an api define them there. E.g.

 public interface TaskService {

     public static final int PRIORITY_LOW = -1;
     public static final int PRIORITY_NORMAL = 0;
     public static final int PRIORITY_HIGH = 1;

     public void schedule(Task task, int priority);
 }

If constants are not releated to a single api define a constants interface. E.g. javax.swing.WindowConstants.

Or is there any other better approach? Note:- I'm looking for best OO technique which would be applicable for this. java

This brings us back to the question how constants are used. Most times they are used to write conditional code. E.g.

 public class TaskServiceImpl implements TaskService {

     private List<Task> lowPriority = new ArrayList<Task>();
     private List<Task> normalPriority = new ArrayList<Task>();
     private List<Task> highPriority = new ArrayList<Task>();

     public void schedule(Task task, int priority){
         if(priority == PRIORITY_HIGH ){
             highPriority.add(task);
         } else if(priority == PRIORITY_LOW ){
             lowPriority.add(task);
         } else if(priority == PRIORITY_NORMAL){
             normalPriority.add(task);
         } else {
             ....
         }
     }
 }

In this case find out what the purpose of the constants is. In the example above the purpose is to group the tasks or if you think further to order them for execution. Move that logic to an own class. E.g. Introduce a Priority class that might implement Compareable ;)

You can also take a look at my blog about type-switches https://www.link-intersystems.com/blog/2015/12/03/enums-as-type-discriminator-anti-pattern/. It is about enum misuse, but it also applies to constants.