Better way to keep String type values globally?

Question

I want some String values to be available/accessible to me throughput the application in Java. Different classes will need them. I want to know the best possible way to keep and access those values throughout the application.

1. One way I know is to use Enum pattern in Java. Where I can associate a String value with each enum and then access it. Like given here. Best way to create enum of strings?

2. Second is to maintain a class of constants with String values.

What is the possible best way so that good design will be followed and everything will be accessed cleanly.

I would like to know.

public class StringValues
{
   public static final String ONE = "one";
   public static final String TWO = "two";
}

I am adding a little more detail.

I am going to create DB queries with these short name Strings. So while instantiating database I will use all the Strings in one place and will create queries.

But after query creation I will need a fragment/part of that String pool for a specific class so that I can register listener for the selected class not for all the Strings in the pool. Every class should know that It needs only 1-2 Strings names to register runtime listener not all the String names.

I need all Strings at one time(during start of application) then I will just need 2 or 3 or more of them but not all.

Here is the code to make you understand my exact design problem.

/**
*This class will be used to create Views in Database.
*/
class Views
{
    public static final String BY_NAME = "byName";
    public static final String BY_DATE = "byDate";
    public static final String BY_GENDER = "byGender";

    //For every String I am going to create Views in Couchbase.
}

/**
*This class knows to which Views it needs to listen to. If any change in its views occurs then
* it will take action. In case of byDate change it is intended to take an action.
*/
public class NewestMember
{
    String[] viewsToQueryFor = {"byDate"};

    //This class will call only these views and will register for them.
}


public class Male
{
    String[] viewsToQueryFor = {"byName", "byGender"};

    //This class will call only these views and will register for them.
}


public class Female
{
    String[] viewsToQueryFor = {"byName", "byGender"};

    //This class will call only these views and will register for them.
}

I do not want to do this. For this I have extra overhead of keeping String values in other classes.

Answer 1

The second one is fine. But I wouldn't create a single class to contain all the unrelated constants. That doesn't scale, and isn't natural. Instead, define the constants in the class where they belong. For example:

public class Victim {
    public static class DEFAULT_MALE_NAME = "John Doe";
    public static class DEFAULT_FEMALE_NAME = "Jane Doe";
    ...
}

public class CreditCard {
    public static final String DEFAULT_TYPE = "Visa";
    ...
}

EDIT:

Now that you provided some code, it seems that you should in fact define one or several enums, that would each encapsulate the concept of a View applied to a given collection.

Answer 2

Since you cannot extend an enum later, the best way is to use constants, i.e. public static final.

Answer 3

I would group the constants and use the second suggestion where the name of the class should be something domain specific instead of only "constants something". Consider a pool of data base field names where each class could represent a table. I would only use this pattern if

1. I require a lot of such values such that I would prefer some grouping.
2. These values are used throughout several parts of my application and I do not want to repeat them in order to avoid for exaple typos.

Otherwise these values should be defined as private constant fields within the using class.

In addition, I would make such classes final and add private constructors that throw an AssertionError (otherwise such constant holer classes could still be created refectively). This makes it clear to every user that these classes should never be used for something else then their constants. I would further avoid interfaces, because they tend to get implemented in order to allow for some sort of static import even though these constant classes do not really represent an actual domain type. This adds some unneccesary verbosity to your application.

Note that Strings (and primitives) are compile time constants and will be inlined by the compiler. This means that these constant holder classes do never get loaded at runtime and there is absolutely no performance or memory penaltiy when using them. It will be just as if you copy-pasted the String to each location it is used. Good grouping is therefore the highest priority. This inlineing does not apply for "string enums" which is why I would discourage their use. If your constant types get more complex than just Strings, I would again consider enums since they can represent interface types and offer a concise way of defining such constants.