Unlike some languages, Apex does not store static final constants within the class code directly, but instead has to execute every assignment in the class the first time you access any of the class's properties. In an organization I previously worked at, our constants class had enough lines of code to add an entire second of CPU time to every transaction that used a constant. And every class and trigger used at least one constant. By switching from final constant
to using a getter for every property, we saved about one second of CPU time from every transaction, including every unit test. Refactoring to use getters saved us something like 5 minutes every time we had to deploy or "run all tests."
Personally, I'd recommend that you keep constants as local as possible, but if you have to use a shared constants class, using getters will dramatically improve your code's performance as you get into the hundreds of properties territory. It does require more overall code, and there are some cases where you shouldn't use it (e.g. if you have properties that use a query, it's probably better for a static final constant), so the overall cost for each design has to be considered. As a general rule of thumb, however, one should first consider using getters over constants, as getters perform better as the number of constants increase.